diff --git a/.agents/skills/modifying-wit-interfaces/SKILL.md b/.agents/skills/modifying-wit-interfaces/SKILL.md
index 669fa96a31..a36df1c21f 100644
--- a/.agents/skills/modifying-wit-interfaces/SKILL.md
+++ b/.agents/skills/modifying-wit-interfaces/SKILL.md
@@ -47,6 +47,7 @@ sub-projects below by copying from the root. **Never manually edit a sub-project
 | `sdks/ts/wit/deps/` | **all** root deps + golem-ai (overlaid from `sdks/ts/wit/golem-ai`) |
 | `sdks/scala/wit/deps/` | **all** root deps |
 | `sdks/moonbit/golem_sdk/wit/deps/` | **all** root deps |
+| `sdks/go/golem/wit/deps/` | **all** root deps |
 
 The exact copy lists live in the `wit-golem-common`, `wit-golem-cli`, and
 `wit-sdks` tasks in `Makefile.toml`.
@@ -90,7 +91,7 @@ This mirrors the correct subset of the root `wit/deps/` into each sub-project, i
 cargo make check-wit
 ```
 
-This re-runs the sync and then `git status` over every per-crate `wit/deps` copy (golem-common, golem-cli, and all four SDKs) to ensure the committed WIT files match what the sync produces. CI runs this; if it fails, you forgot to run `cargo make wit` (or you hand-edited a generated sub-project copy).
+This re-runs the sync and then `git status` over every per-crate `wit/deps` copy (golem-common, golem-cli, and all five SDKs — rust, ts, scala, moonbit, go) to ensure the committed WIT files match what the sync produces. CI runs this; if it fails, you forgot to run `cargo make wit` (or you hand-edited a generated sub-project copy).
 
 ### Step 4: Build and verify
 
@@ -142,7 +143,8 @@ If WIT changes affect SDK interfaces:
 2. **TS SDK**: Rebuild packages (`npx pnpm run build` in `sdks/ts/`), then rebuild agent template WASM (`npx pnpm run build-agent-template`)
 3. **Scala SDK**: Regenerate `agent_guest.wasm`, adjust Scala SDK types or codecs if the WIT shape changed, and run the relevant Scala test suites
 4. **MoonBit SDK**: Regenerate WIT bindings (`wit-bindgen moonbit` in `sdks/moonbit/golem_sdk/`), then `moon fmt` and `moon check --target wasm`
-5. **Test components**: Rebuild any test components that use the changed interfaces (see their `AGENTS.md`)
+5. **Go SDK**: Regenerate WIT bindings (`cargo make generate-sdk-go-bindings`), then `GOOS=wasip1 GOARCH=wasm go build ./...` in `sdks/go/golem/`
+6. **Test components**: Rebuild any test components that use the changed interfaces (see their `AGENTS.md`)
 
 ## Checklist
 
diff --git a/.agents/skills/pre-pr-checklist/SKILL.md b/.agents/skills/pre-pr-checklist/SKILL.md
index 03a4ace6f5..878ec4849f 100644
--- a/.agents/skills/pre-pr-checklist/SKILL.md
+++ b/.agents/skills/pre-pr-checklist/SKILL.md
@@ -32,6 +32,7 @@ Choose tests based on what you changed. **Do not run `cargo make test`** — it
 | Rust SDK (`sdks/rust/`) | `cargo test -p golem-rust` + `cargo make worker-executor-tests` |
 | TypeScript SDK (`sdks/ts/`) | `npx pnpm run test` (in `sdks/ts/`) + `cargo make cli-integration-tests` |
 | MoonBit SDK (`sdks/moonbit/`) | `moon test` (in `sdks/moonbit/golem_sdk/`) |
+| Go SDK (`sdks/go/golem/`) | `go test ./...` (in `sdks/go/golem/`); host-call paths only build under a generated app — see the `sdk-development` skill |
 | CLI structured output/schema | `cargo test -p golem-cli cli_output_schema_ --lib` + `cargo make check-cli-output-schema` |
 | CLI JSON output affecting skill tests | Update affected `golem-skills/tests/harness` code, tests, or scenarios. Run `npm run build && npm test` in `golem-skills/tests/harness` only if harness TypeScript code/tests changed. |
 
@@ -54,6 +55,7 @@ cargo make worker-executor-tests-misc
 | HTTP API endpoints | `cargo make generate-openapi` then `cargo clean -p golem-client && cargo build -p golem-client` (also refreshes `docs/src/content/rest-api/*.mdx`) |
 | Service config structs/defaults | `cargo make generate-configs` |
 | WIT interfaces | `cargo make wit` |
+| Go SDK WIT bindings (after a WIT change) | `cargo make generate-sdk-go-bindings` |
 | TS SDK runtime code | `npx pnpm run build-agent-template` (in `sdks/ts/`) |
 | Skill catalog (`golem-skills/skills/**`) | `cargo make generate-docs-skills` (refreshes `docs/src/content/how-to-guides/*.mdx`) |
 | CLI output schema summary | `cargo make update-cli-output-schema-summary` |
diff --git a/.agents/skills/sdk-development/SKILL.md b/.agents/skills/sdk-development/SKILL.md
index d978237afb..f3d7b7c58b 100644
--- a/.agents/skills/sdk-development/SKILL.md
+++ b/.agents/skills/sdk-development/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: sdk-development
-description: "Working on the Rust, TypeScript, or MoonBit SDKs in sdks/. Use when modifying SDK code, adding SDK features, or testing SDK changes with the main Golem platform."
+description: "Working on the Rust, TypeScript, MoonBit, or Go SDKs in sdks/. Use when modifying SDK code, adding SDK features, releasing an SDK, or testing SDK changes with the main Golem platform."
 ---
 
 # SDK Development
@@ -155,6 +155,94 @@ moon fmt
 moon info    # Regenerate .mbti interface files
 ```
 
+## Go SDK (`sdks/go/golem/`)
+
+Module path **`github.com/golemcloud/golem/sdks/go/golem`**, package `golem`.
+
+The directory is `sdks/go/golem`, not `sdks/go`, on purpose: Go binds an import to the *package
+clause*, but tooling and readers expect it to match the **last path element**. Naming the directory
+`golem` makes them agree, so agents import the SDK with no alias:
+
+```go
+import "github.com/golemcloud/golem/sdks/go/golem"   // binds `golem`
+```
+
+A hyphenated name (`golem-go-sdk`) could not do this — hyphens are not valid Go identifiers, so it
+would force an alias back. It also leaves `sdks/go/` free for siblings.
+
+Built with
+`componentize-go`, which is pinned per-project through Go's `tool` directive — never installed
+globally.
+
+### Building and testing
+
+```shell
+cd sdks/go/golem
+go test ./...                                       # native tests; fast, no wasm needed
+go vet .                                            # host vet, hand-written package
+GOOS=wasip1 GOARCH=wasm go build ./...              # compile everything for the real target
+GOOS=wasip1 GOARCH=wasm go vet -unsafeptr=false -composites=false .
+```
+
+Vet is scoped to `.`, not `./...`: the generated `internal/wit` bindings legitimately trip vet's
+`unsafe.Pointer` / unkeyed-field checks, so the whole tree is *compiled* (the `go build` above), not
+vetted, for the wasm target. CI runs exactly this set — plus a "bindings are committed" check — in the
+`build-golem-go` job (`.github/workflows/ci.yaml`).
+
+Native tests cover everything that does not reach a host import. `empty.s` lets a generated package
+*compile* for the host, but the linker still needs a definition for any `//go:wasmimport` symbol that
+host-arch code actually **references** — so RPC calls, `Future`, and `ClientFor` can only run under
+wasm. Exercise those by creating an app with `golem app new … go` in a playground and building it;
+the playground's `.golem-sdk-overrides` points the generated `go.mod` at this checkout.
+
+### Regenerating WIT bindings
+
+```shell
+cargo make generate-sdk-go-bindings
+```
+
+Generated code lands in `internal/wit/` and is **wiped on every run**. The hand-written export slots
+in `internal/exports/` survive because `--export-pkg-name` points the generated glue at them. The task
+also runs `dev-tools/go-bindgen-fixup`, which works around two upstream wit-bindgen `crates/go` bugs
+(tag-constant collisions, and a missing `empty.s` for the exports package).
+
+### ⚠️ Releasing: Go has no package registry
+
+Every other SDK publishes to a registry (crates.io / npm / maven / mooncakes) from a workflow
+triggered by a `golem-<lang>-v*` tag. **Go has none — the git tag *is* the release**, read directly
+from this repo by `proxy.golang.org`. There is no publish workflow to run.
+
+Because the module lives in a subdirectory, Go **requires** the tag to be prefixed with that
+subdirectory. This is a Go rule, not a choice:
+
+```
+sdks/go/golem/v0.1.0   ✅ the only form Go recognises
+golem-go-v0.1.0        ❌ invisible to Go — do not use
+```
+
+Notes:
+
+- This deliberately breaks the `golem-<lang>-v*` convention the other SDKs follow. It cannot be
+  avoided; see <https://go.dev/ref/mod> ("module subdirectory ... also serves as a prefix for
+  semantic version tags").
+- It does **not** collide with anything. There is no root `go.mod`, so the repo's `v1.5.x` release
+  tags are invisible to Go, and no existing tag has the `sdks/go/golem/` shape.
+- Consumers using the default `GOPROXY` download only the `sdks/go/golem` subtree (~7 MB), not the
+  whole repository. Only `GOPROXY=direct` clones the full repo, once per module cache. Repo size is
+  not a concern: the mirror serves far larger monorepos of exactly this shape (aws-sdk-go-v2 is
+  ~1.2 GB with subdirectory-tagged modules); the only hard limit is 500 MiB on the *module zip*.
+- The mirror stores a module permanently only if it can **detect a license**, and Go has no metadata
+  field for it — `sdks/go/golem/LICENSE` is the only mechanism, so it must stay in the module subtree.
+  It carries the Apache License 2.0 (the current SDK-license direction; a later session aligns the
+  other SDKs, which still ship the Golem Source License for now).
+
+### Local SDK overrides
+
+`GOLEM_GO_PATH` (or `GOLEM_PATH`, which derives it) makes the CLI emit a `replace` directive into a
+generated app's `go.mod`, pointing at the local checkout. This is how the playground tests SDK changes
+without publishing — and, until the first tag exists, the **only** way a generated Go app can resolve
+the SDK.
+
 ## Downstream Rebuild Requirements
 
 SDK changes can require rebuilding test components. This is the most common source of errors.
@@ -176,7 +264,8 @@ SDK changes can require rebuilding test components. This is the most common sour
 
 ## WIT Dependencies
 
-Both SDKs have WIT files synced from the root `wit/` directory. **Never manually edit** `wit/deps/` in either SDK.
+Every SDK has WIT files synced from the root `wit/` directory. **Never manually edit** `wit/deps/` in
+any SDK — `cargo make wit` mirrors them, and `cargo make diff-wit` guards against drift.
 
 ```shell
 # From repository root
@@ -189,6 +278,7 @@ cargo make wit
 2. SDK builds successfully
 3. SDK tests pass
 4. Agent template rebuilt (if TS SDK runtime code changed)
-5. Dependent test components rebuilt (if any)
-6. Platform tests pass (`cargo make worker-executor-tests` for Rust SDK, `cargo make cli-integration-tests` for TS SDK)
-7. Code formatted and linted
+5. Go SDK: a generated app still builds (the only cover for host-call paths)
+6. Dependent test components rebuilt (if any)
+7. Platform tests pass (`cargo make worker-executor-tests` for Rust SDK, `cargo make cli-integration-tests` for TS SDK)
+8. Code formatted and linted
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 0ce607193c..25a0ea57db 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -351,6 +351,28 @@ jobs:
         working-directory: sdks/moonbit/golem_sdk_tools
         run: moon update
 
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          # Stock Go, tracking the version pinned in the module; componentize-go
+          # is a pinned `go tool` (go.mod) that fetches its own toolchain, so the
+          # Go SDK's CLI integration test (test_go_counter) needs only this.
+          go-version-file: sdks/go/golem/go.mod
+          cache-dependency-path: sdks/go/golem/go.sum
+
+      - name: Cache componentize-go toolchain
+        uses: actions/cache@v5
+        with:
+          # On first `golem build` of a Go component, componentize-go downloads a
+          # full patched Go toolchain into this dir (the "will use downloaded
+          # version" build-log line) — hundreds of MB. Cache it so the Go SDK's
+          # CLI integration test doesn't re-fetch it each run. Keyed on the SDK
+          # go.sum, which tracks the pinned componentize-go version.
+          path: ~/.cache/componentize-go
+          key: componentize-go-${{ runner.os }}-${{ hashFiles('sdks/go/golem/go.sum') }}
+          restore-keys: |
+            componentize-go-${{ runner.os }}-
+
       - name: Sync WIT dependencies
         run: cargo make wit
 
@@ -621,6 +643,66 @@ jobs:
         run: cargo test --all-features
         working-directory: sdks/rust
 
+  build-golem-go:
+    runs-on: blacksmith
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          # Tracks the version pinned in the module (currently go 1.25.5); stock
+          # Go only — the SDK deliberately does not use TinyGo.
+          go-version-file: sdks/go/golem/go.mod
+          cache-dependency-path: sdks/go/golem/go.sum
+
+      # cargo-make drives the WIT dep sync and the go-bindgen-fixup step that the
+      # bindings regeneration runs. componentize-go itself is a pinned `go tool`
+      # (go.mod), so no wasm-tools / WASI SDK are needed here.
+      - uses: ./.github/actions/setup-rust
+        with:
+          use-cache: 'false'
+          install-cargo-make: 'true'
+
+      # Regenerate the committed WIT bindings (syncs wit/deps first via the task's
+      # `wit` dependency) and fail if they drift from what's checked in — mirrors
+      # the "types are committed" gate the TS and Scala SDKs use.
+      - name: Regenerate Go WIT bindings
+        run: cargo make generate-sdk-go-bindings
+
+      - name: Verify Go WIT bindings are committed
+        run: |
+          if ! git diff --exit-code sdks/go/golem/internal/wit; then
+            echo "❌ sdks/go/golem/internal/wit differs from the committed version."
+            echo "Please run 'cargo make generate-sdk-go-bindings' and commit the result."
+            exit 1
+          fi
+
+      # Lint the hand-written package with golangci-lint (the standard Go
+      # meta-linter: govet, errcheck, ineffassign, staticcheck, unused + the
+      # doc-comment-form checks). Config + generated-code exclusions live in
+      # sdks/go/golem/.golangci.yml. The official action fetches a pinned binary
+      # and caches analysis — this replaces the host `go vet` step too, since its
+      # govet covers it (and the .golangci.yml exclusions handle the generated
+      # internal/wit bindings that forced the old vet flag workaround).
+      - name: Lint (golangci-lint)
+        uses: golangci/golangci-lint-action@v9
+        with:
+          version: v2.12
+          working-directory: sdks/go/golem
+
+      - name: Vet (wasip1)
+        working-directory: sdks/go/golem
+        run: GOOS=wasip1 GOARCH=wasm go vet -unsafeptr=false -composites=false .
+
+      - name: Build for wasip1
+        working-directory: sdks/go/golem
+        run: GOOS=wasip1 GOARCH=wasm go build ./...
+
+      - name: Run tests
+        working-directory: sdks/go/golem
+        run: go test ./...
+
   build-golem-ts:
     runs-on: blacksmith
     steps:
diff --git a/Cargo.lock b/Cargo.lock
index 4894702fc4..f92b8c06fd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3723,6 +3723,7 @@ dependencies = [
  "tracing-log",
  "tracing-subscriber",
  "tree-sitter",
+ "tree-sitter-go",
  "tree-sitter-json",
  "tree-sitter-rust",
  "tree-sitter-typescript",
@@ -10734,6 +10735,16 @@ dependencies = [
  "tree-sitter-language",
 ]
 
+[[package]]
+name = "tree-sitter-go"
+version = "0.23.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b13d476345220dbe600147dd444165c5791bf85ef53e28acbedd46112ee18431"
+dependencies = [
+ "cc",
+ "tree-sitter-language",
+]
+
 [[package]]
 name = "tree-sitter-json"
 version = "0.24.8"
diff --git a/Cargo.toml b/Cargo.toml
index e73d44cb31..d889ff8b6e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -276,6 +276,7 @@ tracing-serde = "0.2.0"
 tracing-subscriber = { version = "0.3.20", features = ["env-filter", "fmt", "std", "json", ] }
 tracing-test = "0.2.5"
 tree-sitter = "0.26.5"
+tree-sitter-go = "0.23.4"
 tree-sitter-json = "0.24.8"
 tree-sitter-rust = "0.24.0"
 tree-sitter-typescript = "0.23.2"
diff --git a/Makefile.toml b/Makefile.toml
index 362bd6d1c3..50b7eaad5e 100644
--- a/Makefile.toml
+++ b/Makefile.toml
@@ -111,6 +111,7 @@ args = [
     "--src", "wit/deps", "--dst", "sdks/ts/wit/deps",
     "--src", "wit/deps", "--dst", "sdks/scala/wit/deps",
     "--src", "wit/deps", "--dst", "sdks/moonbit/golem_sdk/wit/deps",
+    "--src", "wit/deps", "--dst", "sdks/go/golem/wit/deps",
 ]
 
 [tasks.wit-golem-cli]
@@ -129,7 +130,7 @@ args = [
 private = true
 script_runner = "@duckscript"
 script = '''
-status = exec git status --porcelain -- golem-common/wit/deps cli/golem-cli/wit/deps sdks/rust/golem-rust/wit/deps sdks/ts/wit/deps sdks/scala/wit/deps sdks/moonbit/golem_sdk/wit/deps
+status = exec git status --porcelain -- golem-common/wit/deps cli/golem-cli/wit/deps sdks/rust/golem-rust/wit/deps sdks/ts/wit/deps sdks/scala/wit/deps sdks/moonbit/golem_sdk/wit/deps sdks/go/golem/wit/deps
 ok = eq ${status.code} 0
 if not ${ok}
     echo "git status failed (exit ${status.code}):"
@@ -403,6 +404,33 @@ else
 fi
 '''
 
+[tasks.generate-sdk-go-bindings]
+description = "Regenerates the Go SDK's WIT bindings (sdks/go/golem/internal/wit)"
+dependencies = ["wit"]
+cwd = "./sdks/go/golem"
+script_runner = "@duckscript"
+script = '''
+# The componentize-go version is pinned in sdks/go/golem/go.mod via the `tool` directive
+# (never `latest`); `go tool` therefore resolves the exact pinned build.
+# --all-features is a GLOBAL flag and must precede the subcommand: golem's p3 WIT
+# uses @unstable annotations (timezone).
+# Imports + the wasmexport glue are generated into internal/wit (wiped each run).
+# The export packages are NOT generated: --export-pkg-name points the glue at
+# internal/exports, which we hand-write (the `Exports` slots the SDK fills in at
+# init). That keeps generated and hand-written code strictly separated.
+exec --fail-on-error go tool componentize-go --all-features bindings --output internal/wit --pkg-name github.com/golemcloud/golem/sdks/go/golem/internal/wit --export-pkg-name github.com/golemcloud/golem/sdks/go/golem/internal/exports --format
+
+# Works around a wit-bindgen crates/go codegen bug; see dev-tools/go-bindgen-fixup.
+exec --fail-on-error cargo run --quiet --manifest-path ../../../dev-tools/Cargo.toml --bin go-bindgen-fixup -- internal/wit
+exec --fail-on-error gofmt -w internal/wit
+
+# The generated code is wasm-only (//go:wasmimport declarations have no bodies),
+# so it can only be type-checked for the wasip1 target, not the host.
+set_env GOOS wasip1
+set_env GOARCH wasm
+exec --fail-on-error go build ./internal/wit/...
+'''
+
 [tasks.clean-sdk-scala]
 description = "Cleans the Scala SDK"
 cwd = "./sdks/scala"
diff --git a/cli/golem-cli/Cargo.toml b/cli/golem-cli/Cargo.toml
index 50391c18c5..78e0c9f272 100644
--- a/cli/golem-cli/Cargo.toml
+++ b/cli/golem-cli/Cargo.toml
@@ -101,6 +101,7 @@ tracing = { workspace = true }
 tracing-log = "0.2.0"
 tracing-subscriber = { workspace = true }
 tree-sitter = { workspace = true }
+tree-sitter-go = { workspace = true }
 tree-sitter-json = { workspace = true }
 tree-sitter-rust = { workspace = true }
 tree-sitter-typescript = { workspace = true }
diff --git a/cli/golem-cli/build.rs b/cli/golem-cli/build.rs
index f07d659e06..c9227e32be 100644
--- a/cli/golem-cli/build.rs
+++ b/cli/golem-cli/build.rs
@@ -23,7 +23,7 @@ use std::process::Command;
 static SKIP_ENV_VAR_NAME: &str = "GOLEM_BUILD_SKIP_SHADOW";
 const GENERATED_TEMPLATES_DIR_NAME: &str = "templates";
 const SKILL_DESTINATION: &str = ".agents/skills";
-const SUPPORTED_LANGUAGES: &[&str] = &["ts", "rust", "scala", "moonbit"];
+const SUPPORTED_LANGUAGES: &[&str] = &["ts", "rust", "scala", "moonbit", "go"];
 
 fn main() {
     generate_embedded_templates().unwrap();
diff --git a/cli/golem-cli/src/app/build/check/agents.rs b/cli/golem-cli/src/app/build/check/agents.rs
index fb95cb1c3a..409956d72f 100644
--- a/cli/golem-cli/src/app/build/check/agents.rs
+++ b/cli/golem-cli/src/app/build/check/agents.rs
@@ -120,6 +120,7 @@ mod tests {
             GuestLanguage::TypeScript,
             GuestLanguage::Rust,
             GuestLanguage::MoonBit,
+            GuestLanguage::Go,
         ] {
             let source = repo
                 .common_template_file_contents(language, Path::new("AGENTS.md"))
diff --git a/cli/golem-cli/src/app/build/check/go.rs b/cli/golem-cli/src/app/build/check/go.rs
new file mode 100644
index 0000000000..8d71366044
--- /dev/null
+++ b/cli/golem-cli/src/app/build/check/go.rs
@@ -0,0 +1,72 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// Licensed under the Golem Source License v1.1 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://license.golem.cloud/LICENSE
+//
+// 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.
+
+use crate::app::build::check::DependencyFixStep;
+use crate::app::context::BuildContext;
+use crate::app::edit;
+use crate::fs;
+use crate::model::GuestLanguage;
+use crate::sdk_overrides::{GO_SDK_MODULE, SdkOverrides};
+
+/// Reconcile each Go component's `go.mod` SDK dependency with the active SDK
+/// overrides — mirrors the Rust `Cargo.toml` and TS `package.json` fix steps, so
+/// a committed Go app picks up `GOLEM_GO_PATH`/`GOLEM_GO_VERSION` on build rather
+/// than only at `golem new`.
+///
+/// Simpler than Rust: Go has no workspace concept, so each component is a
+/// standalone module edited independently. `go.mod` sits exactly at the
+/// component dir in both flat (`dir: ""` → app root) and multi-component layouts.
+pub(super) fn plan_go_mod_fix_steps(
+    ctx: &BuildContext<'_>,
+    overrides: &SdkOverrides,
+) -> anyhow::Result<Vec<DependencyFixStep>> {
+    let version = overrides.go_sdk_dep();
+    let replace_path = overrides.go_sdk_path.as_deref();
+
+    let mut steps = Vec::new();
+    for component_name in ctx.application_context().selected_component_names() {
+        let component = ctx.application().component(component_name);
+        if component.guess_language() != Some(GuestLanguage::Go) {
+            continue;
+        }
+
+        let go_mod_path = component.component_dir().join("go.mod");
+        if !go_mod_path.exists() {
+            continue;
+        }
+
+        let original = fs::read_to_string(&go_mod_path)?;
+        let new = edit::go_mod::reconcile_sdk_dependency(
+            &original,
+            GO_SDK_MODULE,
+            &version,
+            replace_path,
+        );
+
+        // A trailing-whitespace-only difference is not a semantic dependency
+        // change — the reconciler always normalizes to a single trailing
+        // newline, but a freshly generated go.mod can carry a trailing blank
+        // line (e.g. an empty replace placeholder in version mode). Skipping it
+        // avoids a spurious go.mod-change confirmation on the first build.
+        if new.trim_end() != original.trim_end() {
+            steps.push(DependencyFixStep {
+                path: go_mod_path,
+                current: original,
+                new,
+            });
+        }
+    }
+
+    Ok(steps)
+}
diff --git a/cli/golem-cli/src/app/build/check/mod.rs b/cli/golem-cli/src/app/build/check/mod.rs
index d48569328d..c01dfbb6f3 100644
--- a/cli/golem-cli/src/app/build/check/mod.rs
+++ b/cli/golem-cli/src/app/build/check/mod.rs
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 mod agents;
+mod go;
 mod requirements;
 mod rust;
 mod skills;
@@ -176,6 +177,11 @@ pub(crate) fn plan_dependency_fixes(
         plan.steps.extend(rust_steps);
     }
 
+    if selected_languages.contains(&GuestLanguage::Go) {
+        let go_steps = go::plan_go_mod_fix_steps(ctx, overrides)?;
+        plan.steps.extend(go_steps);
+    }
+
     if let Some(step) = agents::plan_agents_md_fix_step(ctx, &selected_languages)? {
         plan.steps.push(step);
     }
diff --git a/cli/golem-cli/src/app/build/check/requirements.rs b/cli/golem-cli/src/app/build/check/requirements.rs
index 8d34782b6f..120faff056 100644
--- a/cli/golem-cli/src/app/build/check/requirements.rs
+++ b/cli/golem-cli/src/app/build/check/requirements.rs
@@ -162,12 +162,41 @@ const MOONBIT_TOOL_REQUIREMENTS: &[ToolRequirement] = &[
     },
 ];
 
+// Go needs only the stock `go` toolchain. componentize-go arrives through the
+// project's `tool` directive (so it is pinned per-app, never installed
+// globally), and it downloads the patched Go it needs into its own cache
+// side-by-side with the user's installation.
+const GO_TOOL_REQUIREMENTS: &[ToolRequirement] = &[
+    ToolRequirement {
+        key: "go",
+        name: "Go",
+        check: ToolRequirementCheck::CommandVersion {
+            command: "go",
+            args: &["version"],
+        },
+        version_range: Some(VersionRange::at_least(versions::build_tool::GO_MIN)),
+        install_hint: "Install Go 1.25.5 or newer: https://go.dev/dl/",
+    },
+    // Used by the release preset's `wasm-tools strip` step.
+    ToolRequirement {
+        key: "wasm-tools",
+        name: "wasm-tools",
+        check: ToolRequirementCheck::CommandVersion {
+            command: "wasm-tools",
+            args: &["--version"],
+        },
+        version_range: Some(VersionRange::at_least(versions::build_tool::WASM_TOOLS_MIN)),
+        install_hint: "Install wasm-tools: https://github.com/bytecodealliance/wasm-tools",
+    },
+];
+
 pub fn tool_requirements_for_language(language: GuestLanguage) -> &'static [ToolRequirement] {
     match language {
         GuestLanguage::Rust => RUST_TOOL_REQUIREMENTS,
         GuestLanguage::TypeScript => TYPESCRIPT_TOOL_REQUIREMENTS,
         GuestLanguage::Scala => SCALA_TOOL_REQUIREMENTS,
         GuestLanguage::MoonBit => MOONBIT_TOOL_REQUIREMENTS,
+        GuestLanguage::Go => GO_TOOL_REQUIREMENTS,
     }
 }
 
diff --git a/cli/golem-cli/src/app/build/command.rs b/cli/golem-cli/src/app/build/command.rs
index cd89feb566..de4751528c 100644
--- a/cli/golem-cli/src/app/build/command.rs
+++ b/cli/golem-cli/src/app/build/command.rs
@@ -14,8 +14,9 @@
 
 use crate::app::build::task_result_marker::{
     GenerateQuickJSCrateCommandMarkerHash, GenerateQuickJSDTSCommandMarkerHash,
-    InjectToPrebuiltQuickJsCommandMarkerHash, MoonInstallDepsMarkerHash, NpmInstallDepsMarkerHash,
-    PreinitializeJsCommandMarkerHash, ResolvedExternalCommandMarkerHash, TaskResultMarker,
+    GoModDepsMarkerHash, InjectToPrebuiltQuickJsCommandMarkerHash, MoonInstallDepsMarkerHash,
+    NpmInstallDepsMarkerHash, PreinitializeJsCommandMarkerHash, ResolvedExternalCommandMarkerHash,
+    TaskResultMarker,
 };
 use crate::app::build::up_to_date_check::new_task_up_to_date_check;
 use crate::app::context::BuildContext;
@@ -471,6 +472,22 @@ pub async fn ensure_common_deps_for_tool(
                 })
                 .await
         }
+        "go" => {
+            // Each Go component is its own module, rooted exactly at build_dir
+            // (the componentDir), so there is no ancestor walk like moon needs.
+            let go_mod_path = build_dir.join("go.mod");
+            if !go_mod_path.exists() {
+                return Ok(());
+            }
+
+            let module_root = build_dir.to_path_buf();
+            let ensure_key = format!("go:{}", module_root.display());
+            ctx.tools_with_ensured_common_deps()
+                .ensure_common_deps_for_tool_once(&ensure_key, || async {
+                    ensure_go_dependencies(ctx, &module_root).await
+                })
+                .await
+        }
         _ => Ok(()),
     }
 }
@@ -604,6 +621,79 @@ async fn run_moon_install(app_root_dir: &Path) -> anyhow::Result<()> {
         .await
 }
 
+async fn ensure_go_dependencies(
+    ctx: &BuildContext<'_>,
+    module_root: &Path,
+) -> anyhow::Result<()> {
+    let go_sum_path = module_root.join("go.sum");
+    let marker_dir = ctx.application().task_result_marker_dir();
+
+    // `go mod tidy` rewrites go.mod (indirect requires, block form) and writes
+    // go.sum, so the marker is checked against the CURRENT state but recorded
+    // against the POST-tidy state — otherwise every build would see a changed
+    // go.mod and re-run tidy forever.
+    let go_mod_deps_marker = |root: &Path| -> anyhow::Result<TaskResultMarker> {
+        let go_mod_hash = blake3::hash(&std::fs::read(root.join("go.mod"))?)
+            .to_hex()
+            .to_string();
+        let go_sum_hash = if root.join("go.sum").exists() {
+            Some(
+                blake3::hash(&std::fs::read(root.join("go.sum"))?)
+                    .to_hex()
+                    .to_string(),
+            )
+        } else {
+            None
+        };
+        TaskResultMarker::new(
+            &marker_dir,
+            GoModDepsMarkerHash {
+                go_module_root: root,
+                go_mod_hash: &go_mod_hash,
+                go_sum_hash: go_sum_hash.as_deref(),
+            },
+        )
+    };
+
+    // Up to date only if go.sum exists too: a fresh module has a go.mod but no
+    // go.sum, and componentize-go refuses to build without it.
+    if go_mod_deps_marker(module_root)?.is_up_to_date() && go_sum_path.exists() {
+        return Ok(());
+    }
+
+    if go_sum_path.exists() {
+        log_warn_action(
+            "Detected",
+            format!(
+                "dependency changes, executing {}",
+                "go mod tidy".log_color_highlight()
+            ),
+        );
+    } else {
+        log_warn_action(
+            "Detected",
+            format!(
+                "missing {}, executing {}",
+                "go.sum".log_color_highlight(),
+                "go mod tidy".log_color_highlight()
+            ),
+        );
+    }
+
+    run_go_mod_tidy(module_root).await?;
+
+    // Record success against the post-tidy go.mod/go.sum so the next build skips.
+    go_mod_deps_marker(module_root)?.result(Ok(()))
+}
+
+async fn run_go_mod_tidy(module_root: &Path) -> anyhow::Result<()> {
+    Command::new(which("go")?)
+        .args(["mod", "tidy"])
+        .current_dir(module_root)
+        .stream_and_run("go")
+        .await
+}
+
 fn configure_external_command_env(command: &mut Command, executable: &str, ctx: &BuildContext<'_>) {
     let executable_name = Path::new(executable)
         .file_name()
diff --git a/cli/golem-cli/src/app/build/gen_bridge.rs b/cli/golem-cli/src/app/build/gen_bridge.rs
index c646b25c34..7541e53f28 100644
--- a/cli/golem-cli/src/app/build/gen_bridge.rs
+++ b/cli/golem-cli/src/app/build/gen_bridge.rs
@@ -881,6 +881,12 @@ async fn gen_bridge_sdk_target(
                                 MoonBitBridgeMode::GuestWasmRpc,
                             )?)
                         }
+                        // Go has no bridge generator yet; see
+                        // BridgeSdkTargetKind::supports.
+                        (GuestLanguage::Go, _) => bail!(
+                            "bridge generation is not supported for {} yet",
+                            GuestLanguage::Go.to_string().log_color_highlight()
+                        ),
                     };
 
                         fs::remove(&output_dir)?;
diff --git a/cli/golem-cli/src/app/build/task_result_marker.rs b/cli/golem-cli/src/app/build/task_result_marker.rs
index 32a7a10241..fd6dadfcc0 100644
--- a/cli/golem-cli/src/app/build/task_result_marker.rs
+++ b/cli/golem-cli/src/app/build/task_result_marker.rs
@@ -124,6 +124,30 @@ impl TaskResultMarkerHashSource for MoonInstallDepsMarkerHash<'_> {
     }
 }
 
+#[derive(Serialize)]
+pub struct GoModDepsMarkerHash<'a> {
+    pub go_module_root: &'a Path,
+    pub go_mod_hash: &'a str,
+    pub go_sum_hash: Option<&'a str>,
+}
+
+impl TaskResultMarkerHashSource for GoModDepsMarkerHash<'_> {
+    fn kind() -> &'static str {
+        "GoModDepsMarkerHash"
+    }
+
+    fn id(&self) -> anyhow::Result<Option<String>> {
+        Ok(Some(format!(
+            "go-mod-deps:{}",
+            self.go_module_root.display()
+        )))
+    }
+
+    fn source(&self) -> anyhow::Result<TaskResultMarkerHashSourceKind> {
+        Ok(HashFromString(serde_json::to_string(self)?))
+    }
+}
+
 impl TaskResultMarkerHashSource for ResolvedExternalCommandMarkerHash<'_> {
     fn kind() -> &'static str {
         "ResolvedExternalCommandMarkerHash"
diff --git a/cli/golem-cli/src/app/edit/go_mod.rs b/cli/golem-cli/src/app/edit/go_mod.rs
new file mode 100644
index 0000000000..cfcb4efca2
--- /dev/null
+++ b/cli/golem-cli/src/app/edit/go_mod.rs
@@ -0,0 +1,236 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// Licensed under the Golem Source License v1.1 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://license.golem.cloud/LICENSE
+//
+// 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.
+
+//! Minimal, formatting-tolerant `go.mod` editing for reconciling the Golem SDK
+//! dependency with the active SDK overrides on every build (mirrors the Rust
+//! `Cargo.toml` and TS `package.json` fix steps).
+//!
+//! Only two things are touched, both anchored on the SDK module path:
+//!   - the `require` version for the SDK module (single-line or block form);
+//!   - a top-level `replace <module> => <path>` directive — present when a local
+//!     SDK path override is active, absent otherwise.
+//!
+//! `go mod tidy` reformats `go.mod` (block requires, tabs), so matching is by
+//! module path and structure, never exact text.
+
+/// Reconcile the SDK dependency in `content`:
+///   - set the SDK module's `require` version to `version`;
+///   - if `replace_path` is `Some`, ensure `replace <module> => <path>`;
+///   - if `None`, remove any such replace directive.
+///
+/// Returns the updated `go.mod` text. A trailing newline is preserved/ensured.
+pub fn reconcile_sdk_dependency(
+    content: &str,
+    module: &str,
+    version: &str,
+    replace_path: Option<&str>,
+) -> String {
+    let mut lines: Vec<String> = content.lines().map(|l| l.to_string()).collect();
+
+    set_require_version(&mut lines, module, version);
+    set_replace_directive(&mut lines, module, replace_path);
+
+    let mut out = lines.join("\n");
+    if !out.ends_with('\n') {
+        out.push('\n');
+    }
+    out
+}
+
+/// A `require` entry for `module` — either `require <module> <ver>` (single) or
+/// `<module> <ver>` inside a `require (…)` block — has its version set. A require
+/// line has no `=>` (which distinguishes it from a `replace` line that also
+/// names the module).
+fn set_require_version(lines: &mut [String], module: &str, version: &str) {
+    let mut in_require_block = false;
+    for line in lines.iter_mut() {
+        let trimmed = line.trim();
+
+        if !in_require_block && trimmed.starts_with("require (") {
+            in_require_block = true;
+            continue;
+        }
+        if in_require_block && trimmed == ")" {
+            in_require_block = false;
+            continue;
+        }
+
+        if trimmed.contains("=>") {
+            continue; // replace line, not require
+        }
+
+        // Single-line: `require <module> <ver>`
+        if let Some(rest) = trimmed.strip_prefix("require ") {
+            if first_token(rest) == Some(module) {
+                let indent = leading_ws(line);
+                let suffix = trailing_comment(rest);
+                *line = format!("{indent}require {module} {version}{suffix}");
+            }
+            continue;
+        }
+
+        // Block entry: `<module> <ver>`
+        if in_require_block && first_token(trimmed) == Some(module) {
+            let indent = leading_ws(line);
+            let suffix = trailing_comment(trimmed);
+            *line = format!("{indent}{module} {version}{suffix}");
+        }
+    }
+}
+
+/// Ensure or remove a top-level `replace <module> => <path>` directive.
+/// Replace *blocks* are also handled: an entry `<module> => <path>` inside a
+/// `replace (…)` block is updated or removed.
+fn set_replace_directive(lines: &mut Vec<String>, module: &str, replace_path: Option<&str>) {
+    let mut updated = false;
+    let mut in_replace_block = false;
+    let mut removals = Vec::new();
+
+    for (idx, line) in lines.iter_mut().enumerate() {
+        let trimmed = line.trim();
+
+        if !in_replace_block && trimmed.starts_with("replace (") {
+            in_replace_block = true;
+            continue;
+        }
+        if in_replace_block && trimmed == ")" {
+            in_replace_block = false;
+            continue;
+        }
+
+        let is_single = trimmed
+            .strip_prefix("replace ")
+            .map(|rest| replace_lhs_is(rest, module))
+            .unwrap_or(false);
+        let is_block_entry = in_replace_block && replace_lhs_is(trimmed, module);
+
+        if is_single || is_block_entry {
+            match replace_path {
+                Some(path) if is_single => {
+                    *line = format!("replace {module} => {path}");
+                    updated = true;
+                }
+                Some(path) => {
+                    let indent = leading_ws(line);
+                    *line = format!("{indent}{module} => {path}");
+                    updated = true;
+                }
+                None => removals.push(idx),
+            }
+        }
+    }
+
+    for idx in removals.into_iter().rev() {
+        lines.remove(idx);
+    }
+
+    // Append a fresh directive if wanted but none existed.
+    if let Some(path) = replace_path {
+        if !updated {
+            if !lines.last().map(|l| l.trim().is_empty()).unwrap_or(false) {
+                lines.push(String::new());
+            }
+            lines.push(format!("replace {module} => {path}"));
+        }
+    }
+}
+
+/// True if the text before `=>` names exactly `module` (ignoring an optional
+/// version token, e.g. `replace mod v1 => …`).
+fn replace_lhs_is(rest: &str, module: &str) -> bool {
+    match rest.split("=>").next() {
+        Some(lhs) => lhs.split_whitespace().next() == Some(module),
+        None => false,
+    }
+}
+
+fn first_token(s: &str) -> Option<&str> {
+    s.split_whitespace().next()
+}
+
+fn leading_ws(line: &str) -> &str {
+    &line[..line.len() - line.trim_start().len()]
+}
+
+/// The trailing `// …` comment of a require entry (e.g. ` // indirect`),
+/// including its leading space, or empty.
+fn trailing_comment(entry: &str) -> String {
+    match entry.find("//") {
+        Some(pos) => format!(" {}", entry[pos..].trim_end()),
+        None => String::new(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use test_r::test;
+
+    const MOD: &str = "github.com/golemcloud/golem/sdks/go/golem";
+
+    #[test]
+    fn sets_version_in_a_block_and_adds_replace() {
+        let src = format!(
+            "module app\n\ngo 1.25.5\n\nrequire (\n\t{MOD} v0.0.0\n\tgithub.com/bytecodealliance/componentize-go v0.4.0\n)\n\ntool github.com/bytecodealliance/componentize-go\n"
+        );
+        let out = reconcile_sdk_dependency(&src, MOD, "v0.0.0", Some("/abs/sdks/go/golem"));
+        assert!(out.contains(&format!("\t{MOD} v0.0.0\n")));
+        assert!(out.contains(&format!("replace {MOD} => /abs/sdks/go/golem")));
+        // componentize-go untouched
+        assert!(out.contains("github.com/bytecodealliance/componentize-go v0.4.0"));
+    }
+
+    #[test]
+    fn updates_version_single_line() {
+        let src = format!("module app\n\nrequire {MOD} v0.0.0\n");
+        let out = reconcile_sdk_dependency(&src, MOD, "v0.1.0", None);
+        assert!(out.contains(&format!("require {MOD} v0.1.0\n")));
+    }
+
+    #[test]
+    fn removes_replace_when_switching_to_version() {
+        let src = format!(
+            "module app\n\nrequire {MOD} v0.0.0\n\nreplace {MOD} => /abs/sdks/go/golem\n"
+        );
+        let out = reconcile_sdk_dependency(&src, MOD, "v0.1.0", None);
+        assert!(!out.contains("replace"));
+        assert!(out.contains(&format!("require {MOD} v0.1.0")));
+    }
+
+    #[test]
+    fn updates_existing_replace_path() {
+        let src = format!("module app\n\nrequire {MOD} v0.0.0\n\nreplace {MOD} => /old/path\n");
+        let out = reconcile_sdk_dependency(&src, MOD, "v0.0.0", Some("/new/path"));
+        assert!(out.contains(&format!("replace {MOD} => /new/path")));
+        assert!(!out.contains("/old/path"));
+    }
+
+    #[test]
+    fn preserves_indirect_comment_on_block_entries() {
+        let src = format!(
+            "module app\n\nrequire (\n\t{MOD} v0.0.0\n\tgolang.org/x/sys v0.37.0 // indirect\n)\n"
+        );
+        let out = reconcile_sdk_dependency(&src, MOD, "v0.2.0", None);
+        assert!(out.contains("golang.org/x/sys v0.37.0 // indirect"));
+        assert!(out.contains(&format!("{MOD} v0.2.0")));
+    }
+
+    #[test]
+    fn idempotent_when_already_reconciled() {
+        let src = format!("module app\n\nrequire {MOD} v0.0.0\n\nreplace {MOD} => /p\n");
+        let once = reconcile_sdk_dependency(&src, MOD, "v0.0.0", Some("/p"));
+        let twice = reconcile_sdk_dependency(&once, MOD, "v0.0.0", Some("/p"));
+        assert_eq!(once, twice);
+    }
+}
diff --git a/cli/golem-cli/src/app/edit/main_go.rs b/cli/golem-cli/src/app/edit/main_go.rs
new file mode 100644
index 0000000000..c698641d83
--- /dev/null
+++ b/cli/golem-cli/src/app/edit/main_go.rs
@@ -0,0 +1,128 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// Licensed under the Golem Source License v1.1 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://license.golem.cloud/LICENSE
+//
+// 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.
+
+use anyhow::anyhow;
+use std::collections::BTreeMap;
+use tree_sitter::{Parser, Tree};
+
+pub fn validate(source: &str) -> anyhow::Result<()> {
+    let _ = parse_go(source)?;
+    Ok(())
+}
+
+/// Merge the imports of `update`'s `main.go` into `current`'s, rewriting the
+/// import block into gofmt-canonical form: a single, lexically sorted,
+/// tab-indented `import (…)` group. `func main` and any comments around the
+/// import block are left untouched.
+///
+/// Composing Go agent templates means unioning the blank imports of the agent
+/// packages into the component's single `main.go`. Go's `gofmt` is strict about import
+/// grouping and ordering, so rather than text-inserting (which would leave an
+/// unsorted block that compiles but fails a format check) we rebuild the block
+/// canonically — clean by construction, mirroring how `main_rs.rs` rewrites its
+/// `mod`/`pub use` block.
+pub fn merge_imports(current: &str, update: &str) -> anyhow::Result<String> {
+    let current_tree = parse_go(current)?;
+    let update_tree = parse_go(update)?;
+
+    // Keyed by import path (quoted, as written) so a repeated import dedups; the
+    // value is the full spec text (`_ "path"`, `alias "path"`, or `"path"`).
+    let mut specs: BTreeMap<String, String> = BTreeMap::new();
+    collect_import_specs(current, &current_tree, &mut specs);
+    let before = specs.len();
+    collect_import_specs(update, &update_tree, &mut specs);
+    if specs.len() == before {
+        // update contributes no new import — nothing to merge.
+        return Ok(current.to_string());
+    }
+
+    let (start, end) = import_span(&current_tree)
+        .ok_or_else(|| anyhow!("main.go has no import declaration to merge into"))?;
+
+    let mut block = String::from("import (\n");
+    for spec in specs.values() {
+        block.push('\t');
+        block.push_str(spec);
+        block.push('\n');
+    }
+    block.push(')');
+
+    let mut output = String::with_capacity(current.len() + block.len());
+    output.push_str(&current[..start]);
+    output.push_str(&block);
+    output.push_str(&current[end..]);
+    Ok(output)
+}
+
+fn parse_go(source: &str) -> anyhow::Result<Tree> {
+    let mut parser = Parser::new();
+    parser
+        .set_language(&tree_sitter_go::LANGUAGE.into())
+        .map_err(|_| anyhow!("Failed to load tree-sitter-go"))?;
+    let tree = parser
+        .parse(source, None)
+        .ok_or_else(|| anyhow!("Failed to parse Go"))?;
+    if tree.root_node().has_error() {
+        return Err(anyhow!("Invalid Go"));
+    }
+    Ok(tree)
+}
+
+/// Walks every `import_spec` in the tree, recording (path → spec text). The path
+/// is the quoted string as written (a stable dedup key that also sorts by path,
+/// since all our imports are blank); the spec preserves any name/alias so a
+/// non-blank import in main.go survives a merge.
+fn collect_import_specs(source: &str, tree: &Tree, out: &mut BTreeMap<String, String>) {
+    let root = tree.root_node();
+    let mut cursor = root.walk();
+    let mut stack = vec![root];
+    while let Some(node) = stack.pop() {
+        if node.kind() == "import_spec" {
+            if let Some(path_node) = node.child_by_field_name("path") {
+                let path = &source[path_node.start_byte()..path_node.end_byte()];
+                let spec = match node.child_by_field_name("name") {
+                    Some(name_node) => {
+                        let name = &source[name_node.start_byte()..name_node.end_byte()];
+                        format!("{name} {path}")
+                    }
+                    None => path.to_string(),
+                };
+                out.insert(path.to_string(), spec);
+            }
+        }
+        for child in node.named_children(&mut cursor) {
+            stack.push(child);
+        }
+    }
+}
+
+/// Byte span covering the import declaration(s) at the top level, from the first
+/// `import` keyword to the end of the last import declaration. `main.go` carries
+/// a single block, but spanning first→last keeps a stray second declaration from
+/// surviving the rewrite.
+fn import_span(tree: &Tree) -> Option<(usize, usize)> {
+    let root = tree.root_node();
+    let mut cursor = root.walk();
+    let mut start = None;
+    let mut end = None;
+    for child in root.named_children(&mut cursor) {
+        if child.kind() == "import_declaration" {
+            if start.is_none() {
+                start = Some(child.start_byte());
+            }
+            end = Some(child.end_byte());
+        }
+    }
+    start.zip(end)
+}
diff --git a/cli/golem-cli/src/app/edit/mod.rs b/cli/golem-cli/src/app/edit/mod.rs
index fb95c7366d..5c4878ce39 100644
--- a/cli/golem-cli/src/app/edit/mod.rs
+++ b/cli/golem-cli/src/app/edit/mod.rs
@@ -16,8 +16,10 @@ pub mod agents_md;
 pub mod build_sbt;
 pub mod cargo_toml;
 pub mod gitignore;
+pub mod go_mod;
 pub mod golem_yaml;
 pub mod json;
+pub mod main_go;
 pub mod main_rs;
 pub mod main_ts;
 pub mod package_json;
diff --git a/cli/golem-cli/src/app/edit/tests.rs b/cli/golem-cli/src/app/edit/tests.rs
index 59e72e9a54..c24a401352 100644
--- a/cli/golem-cli/src/app/edit/tests.rs
+++ b/cli/golem-cli/src/app/edit/tests.rs
@@ -15,7 +15,7 @@
 use crate::app::edit::cargo_toml::DependencySpec;
 use crate::app::edit::cargo_toml::{DependencyLocation, DependencyTable};
 use crate::app::edit::{
-    agents_md, cargo_toml, gitignore, golem_yaml, json, main_rs, main_ts, package_json,
+    agents_md, cargo_toml, gitignore, golem_yaml, json, main_go, main_rs, main_ts, package_json,
     tsconfig_json,
 };
 use crate::model::GuestLanguage;
@@ -875,6 +875,59 @@ import './b';
     assert_eq!(merged, current);
 }
 
+#[test]
+fn main_go_merge_imports_adds_new_sorted() {
+    let current = r#"package main
+
+// keep this import — it initializes the SDK runtime.
+import (
+	_ "github.com/golemcloud/golem/sdks/go/golem"
+	_ "app-counter/counter"
+)
+
+func main() {}
+"#;
+    let update = r#"package main
+
+import _ "app-counter/session"
+"#;
+    let merged = main_go::merge_imports(current, update).unwrap();
+    let expected = r#"package main
+
+// keep this import — it initializes the SDK runtime.
+import (
+	_ "app-counter/counter"
+	_ "app-counter/session"
+	_ "github.com/golemcloud/golem/sdks/go/golem"
+)
+
+func main() {}
+"#;
+    assert_eq!(merged, expected);
+    // Result is canonical gofmt: sorted, tab-indented, one group, and re-parses.
+    main_go::validate(&merged).unwrap();
+}
+
+#[test]
+fn main_go_merge_imports_dedups_and_keeps_current() {
+    let current = r#"package main
+
+import (
+	_ "app-counter/counter"
+	_ "github.com/golemcloud/golem/sdks/go/golem"
+)
+
+func main() {}
+"#;
+    // Re-applying an agent whose import is already present is a no-op.
+    let update = r#"package main
+
+import _ "app-counter/counter"
+"#;
+    let merged = main_go::merge_imports(current, update).unwrap();
+    assert_eq!(merged, current);
+}
+
 #[test]
 fn main_rs_import_export() {
     let source = r#"use std::fmt;
diff --git a/cli/golem-cli/src/app/template/generator.rs b/cli/golem-cli/src/app/template/generator.rs
index 9c53f742ed..fe7586857c 100644
--- a/cli/golem-cli/src/app/template/generator.rs
+++ b/cli/golem-cli/src/app/template/generator.rs
@@ -16,7 +16,7 @@ use crate::app::template::AppTemplate;
 use crate::app::template::repo::TEMPLATES_DIR;
 use crate::app::template::snippet::{APP_MANIFEST_HEADER, DEP_ENV_VARS_DOC};
 use crate::fs;
-use crate::sdk_overrides::sdk_overrides;
+use crate::sdk_overrides::{GO_SDK_MODULE, sdk_overrides};
 use crate::versions;
 use anyhow::{anyhow, bail};
 use golem_common::base_model::application::ApplicationName;
@@ -102,6 +102,7 @@ enum Transform {
     RustSdk,
     ScalaSdk,
     MoonBitSdk,
+    GoSdk,
     ApplicationName,
 }
 
@@ -290,6 +291,7 @@ fn generate_directory<T: TemplateGeneratorTargetFs>(
                             Transform::ManifestHints,
                             Transform::ApplicationName,
                             Transform::MoonBitSdk,
+                            Transform::GoSdk,
                         ]
                     }
                     (true, "package.json") => vec![Transform::TsSdk],
@@ -310,6 +312,7 @@ fn generate_directory<T: TemplateGeneratorTargetFs>(
                         ]
                     }
                     (false, "package.json") => vec![Transform::TsSdk],
+                    (false, "go.mod") => vec![Transform::ComponentName, Transform::GoSdk],
                     (false, "Cargo.toml") => vec![Transform::ComponentName, Transform::RustSdk],
                     (false, "build.sbt") => vec![
                         Transform::ComponentName,
@@ -465,6 +468,20 @@ fn transform(
                     sdk_overrides.moonbit_sdk_build_path(),
                 );
             }
+            Transform::GoSdk => {
+                replacements.insert("GOLEM_GO_DEP_SDK_MODULE", GO_SDK_MODULE.to_string());
+                replacements.insert("GOLEM_GO_DEP_SDK_VERSION", sdk_overrides.go_sdk_dep());
+                // Empty unless a local SDK checkout is being used.
+                replacements.insert("GOLEM_GO_DEP_SDK_REPLACE", sdk_overrides.go_sdk_replace());
+                replacements.insert(
+                    "GOLEM_GO_DEP_GO_VERSION",
+                    versions::build_tool::GO_MIN.to_string(),
+                );
+                replacements.insert(
+                    "GOLEM_GO_DEP_COMPONENTIZE_GO_VERSION",
+                    versions::go_dep::COMPONENTIZE_GO.to_string(),
+                );
+            }
             Transform::TsSdk => {
                 replacements.insert(
                     "GOLEM_TS_SDK_VERSION_OR_PATH",
@@ -555,7 +572,8 @@ fn transform_file_name(
     file_name: impl AsRef<str>,
 ) -> anyhow::Result<String> {
     Ok(transform(ctx, file_name, &[Transform::ComponentName])?
-        .replace("Cargo.toml._", "Cargo.toml"))
+        .replace("Cargo.toml._", "Cargo.toml")
+        .replace("go.mod._", "go.mod"))
 }
 
 fn transform_target_file_path(
diff --git a/cli/golem-cli/src/app/template/plan.rs b/cli/golem-cli/src/app/template/plan.rs
index 6b0dd7db1a..d4d0699282 100644
--- a/cli/golem-cli/src/app/template/plan.rs
+++ b/cli/golem-cli/src/app/template/plan.rs
@@ -348,6 +348,12 @@ fn try_merge(path: &Path, current: &str, new: &str) -> anyhow::Result<Option<Str
                 validate_yaml,
                 edit::golem_yaml::merge_documents,
             )?),
+            "main.go" => Some(merge_with_validation(
+                current,
+                new,
+                edit::main_go::validate,
+                edit::main_go::merge_imports,
+            )?),
             "main.ts" => Some(merge_with_validation(
                 current,
                 new,
diff --git a/cli/golem-cli/src/command_handler/app/template.rs b/cli/golem-cli/src/command_handler/app/template.rs
index fd27300c7e..fad005dd71 100644
--- a/cli/golem-cli/src/command_handler/app/template.rs
+++ b/cli/golem-cli/src/command_handler/app/template.rs
@@ -820,6 +820,38 @@ impl TemplateHandler {
                     },
                 });
             }
+            GuestLanguage::Go => {
+                let target_root = application_path.join(new_component_dir);
+
+                // Each Go component is its own module, so the whole module moves
+                // with the component: go.mod/go.sum plus every root .go file.
+                // (componentize-go only resolves the SDK's WIT when it runs from
+                // a module root, which is why the module cannot stay behind.)
+                for name in ["go.mod", "go.sum"] {
+                    let source = application_path.join(name);
+                    if source.exists() {
+                        upgrade_plan.add(MultiComponentLayoutUpgradePlanStep::Move {
+                            source,
+                            target: target_root.join(name),
+                        });
+                    }
+                }
+
+                for entry in std::fs::read_dir(application_path)? {
+                    let entry = entry?;
+                    let path = entry.path();
+                    if path.is_file() && path.extension().and_then(|e| e.to_str()) == Some("go") {
+                        let file_name = entry.file_name();
+                        upgrade_plan.add(MultiComponentLayoutUpgradePlanStep::Move {
+                            source: path.clone(),
+                            target: target_root.join(&file_name),
+                        });
+                    }
+                }
+
+                // golem-temp deliberately NOT moved: Go build output goes to the
+                // app-root golem-temp (like TS and Scala), so it stays put.
+            }
             GuestLanguage::MoonBit => {
                 let target_root = application_path.join(new_component_dir);
 
diff --git a/cli/golem-cli/src/command_handler/secret.rs b/cli/golem-cli/src/command_handler/secret.rs
index daa511dd37..2705430e6e 100644
--- a/cli/golem-cli/src/command_handler/secret.rs
+++ b/cli/golem-cli/src/command_handler/secret.rs
@@ -259,6 +259,9 @@ impl SecretCommandHandler {
                     GuestLanguage::TypeScript => SourceLanguage::TypeScript,
                     GuestLanguage::Scala => SourceLanguage::Scala,
                     GuestLanguage::MoonBit => SourceLanguage::MoonBit,
+                    // No Go agent-id renderer/parser yet; Other(_) falls back to
+                    // the TypeScript-style syntax. Matches model/deploy.rs.
+                    GuestLanguage::Go => SourceLanguage::Other("go".to_string()),
                 };
             }
         }
diff --git a/cli/golem-cli/src/model/app.rs b/cli/golem-cli/src/model/app.rs
index 7089ca7ae8..1108f9f8c8 100644
--- a/cli/golem-cli/src/model/app.rs
+++ b/cli/golem-cli/src/model/app.rs
@@ -411,6 +411,9 @@ impl BridgeSdkTargetKind {
                 | GuestLanguage::Scala
                 | GuestLanguage::MoonBit,
             ) => false,
+            // No bridge generation for Go yet (no src/bridge_gen/go); cross-component
+            // clients for Go are written by hand against the SDK until it lands.
+            (_, _, GuestLanguage::Go) => false,
         }
     }
 
@@ -1836,6 +1839,7 @@ impl<'a> Component<'a> {
                     "rust" => Some(GuestLanguage::Rust),
                     "scala" => Some(GuestLanguage::Scala),
                     "moonbit" => Some(GuestLanguage::MoonBit),
+                    "go" => Some(GuestLanguage::Go),
                     _ => None,
                 })
         })
diff --git a/cli/golem-cli/src/model/app_raw.rs b/cli/golem-cli/src/model/app_raw.rs
index acea46b456..09682fb3d8 100644
--- a/cli/golem-cli/src/model/app_raw.rs
+++ b/cli/golem-cli/src/model/app_raw.rs
@@ -1124,6 +1124,8 @@ impl BridgeSdks {
             GuestLanguage::TypeScript => self.ts.as_ref(),
             GuestLanguage::Scala => self.scala.as_ref(),
             GuestLanguage::MoonBit => self.moonbit.as_ref(),
+            // No bridge SDK targets for Go; see BridgeSdkTargetKind::supports.
+            GuestLanguage::Go => None,
         }
     }
 
diff --git a/cli/golem-cli/src/model/deploy.rs b/cli/golem-cli/src/model/deploy.rs
index fd99c7ffba..b9702db008 100644
--- a/cli/golem-cli/src/model/deploy.rs
+++ b/cli/golem-cli/src/model/deploy.rs
@@ -405,6 +405,9 @@ pub fn preferred_source_language_for_setup(
         Some(GuestLanguage::TypeScript) => SourceLanguage::TypeScript,
         Some(GuestLanguage::Scala) => SourceLanguage::Scala,
         Some(GuestLanguage::MoonBit) => SourceLanguage::MoonBit,
+        // The Go SDK reports "go" as its source-language; there is no dedicated
+        // agent-id renderer/parser for it yet, so it takes the Other(_) path.
+        Some(GuestLanguage::Go) => SourceLanguage::Other("go".to_string()),
         None => SourceLanguage::Other(String::new()),
     }
 }
diff --git a/cli/golem-cli/src/model/mod.rs b/cli/golem-cli/src/model/mod.rs
index 7564001414..c6457df1ec 100644
--- a/cli/golem-cli/src/model/mod.rs
+++ b/cli/golem-cli/src/model/mod.rs
@@ -79,6 +79,8 @@ pub enum GuestLanguage {
     Rust,
     Scala,
     MoonBit,
+    #[value(alias = "golang")]
+    Go,
 }
 
 impl GuestLanguage {
@@ -88,6 +90,7 @@ impl GuestLanguage {
             "ts" | "typescript" => Some(GuestLanguage::TypeScript),
             "scala" => Some(GuestLanguage::Scala),
             "moonbit" => Some(GuestLanguage::MoonBit),
+            "go" | "golang" => Some(GuestLanguage::Go),
             _ => None,
         }
     }
@@ -98,6 +101,7 @@ impl GuestLanguage {
             "ts" => Some(GuestLanguage::TypeScript),
             "scala" => Some(GuestLanguage::Scala),
             "moonbit" => Some(GuestLanguage::MoonBit),
+            "go" => Some(GuestLanguage::Go),
             _ => None,
         }
     }
@@ -108,6 +112,7 @@ impl GuestLanguage {
             GuestLanguage::TypeScript => "ts",
             GuestLanguage::Scala => "scala",
             GuestLanguage::MoonBit => "moonbit",
+            GuestLanguage::Go => "go",
         }
     }
 
@@ -117,6 +122,7 @@ impl GuestLanguage {
             GuestLanguage::TypeScript => "TypeScript",
             GuestLanguage::Scala => "Scala",
             GuestLanguage::MoonBit => "MoonBit",
+            GuestLanguage::Go => "Go",
         }
     }
 }
diff --git a/cli/golem-cli/src/sdk_overrides.rs b/cli/golem-cli/src/sdk_overrides.rs
index 5217a18bc1..af05be3e13 100644
--- a/cli/golem-cli/src/sdk_overrides.rs
+++ b/cli/golem-cli/src/sdk_overrides.rs
@@ -29,8 +29,10 @@ const GOLEM_TS_VERSION: &str = "GOLEM_TS_VERSION";
 const GOLEM_SCALA_SDK_VERSION: &str = "GOLEM_SCALA_SDK_VERSION";
 const GOLEM_MOONBIT_SDK_PATH: &str = "GOLEM_MOONBIT_SDK_PATH";
 const GOLEM_MOONBIT_SDK_VERSION: &str = "GOLEM_MOONBIT_SDK_VERSION";
+const GOLEM_GO_PATH: &str = "GOLEM_GO_PATH";
+const GOLEM_GO_VERSION: &str = "GOLEM_GO_VERSION";
 
-const SDK_OVERRIDE_KEYS: [&str; 8] = [
+const SDK_OVERRIDE_KEYS: [&str; 10] = [
     GOLEM_PATH,
     GOLEM_RUST_PATH,
     GOLEM_RUST_VERSION,
@@ -39,10 +41,15 @@ const SDK_OVERRIDE_KEYS: [&str; 8] = [
     GOLEM_SCALA_SDK_VERSION,
     GOLEM_MOONBIT_SDK_PATH,
     GOLEM_MOONBIT_SDK_VERSION,
+    GOLEM_GO_PATH,
+    GOLEM_GO_VERSION,
 ];
 
 pub const SDK_OVERRIDES_FILE_NAME: &str = ".golem-sdk-overrides";
 
+/// Module path of the Go SDK, as required/replaced in a generated `go.mod`.
+pub const GO_SDK_MODULE: &str = "github.com/golemcloud/golem/sdks/go/golem";
+
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub enum SdkOverridesTestProfile {
     LocalWorkspace,
@@ -65,6 +72,8 @@ pub struct SdkOverrides {
     pub scala_sdk_version: Option<String>,
     pub moonbit_sdk_path: Option<String>,
     pub moonbit_sdk_version: Option<String>,
+    pub go_sdk_path: Option<String>,
+    pub go_sdk_version: Option<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -96,6 +105,8 @@ impl SdkOverrides {
                 fs::path_to_str(&workspace_dir.join("sdks/moonbit/golem_sdk"))?.to_string(),
             ),
             moonbit_sdk_version: None,
+            go_sdk_path: Some(fs::path_to_str(&workspace_dir.join("sdks/go/golem"))?.to_string()),
+            go_sdk_version: None,
         }
         .to_env_vars())
     }
@@ -138,6 +149,38 @@ impl SdkOverrides {
         }
     }
 
+    /// The version for the SDK's `require` line in a generated `go.mod`.
+    ///
+    /// When a local path override is active the version is a placeholder: the
+    /// `replace` directive from [`Self::go_sdk_replace`] is what actually
+    /// resolves the module, and Go requires the module to be `require`d anyway.
+    pub fn go_sdk_dep(&self) -> String {
+        match &self.go_sdk_path {
+            Some(_) => "v0.0.0".to_string(),
+            None => format!(
+                "v{}",
+                self.go_sdk_version.as_deref().unwrap_or(versions::sdk::GO)
+            ),
+        }
+    }
+
+    /// The `replace` directive pointing at a local SDK checkout, or an empty
+    /// string when resolving the SDK from the module proxy.
+    ///
+    /// No trailing newline: the template placeholder sits on its own line, so
+    /// the line's own newline terminates the file with exactly one — matching
+    /// the canonical form `edit::go_mod::reconcile_sdk_dependency` produces, so a
+    /// freshly generated app's first build does not report a spurious go.mod
+    /// change (path mode).
+    pub fn go_sdk_replace(&self) -> String {
+        match &self.go_sdk_path {
+            Some(path) => {
+                format!("\nreplace {GO_SDK_MODULE} => {path}")
+            }
+            None => String::new(),
+        }
+    }
+
     pub fn moonbit_sdk_tools_bin_deps(&self) -> String {
         match &self.moonbit_sdk_path {
             Some(_) => String::new(),
@@ -327,6 +370,13 @@ impl SdkOverrides {
                 "sdks/moonbit/golem_sdk",
             )?,
             moonbit_sdk_version: get_normalized_value_by_key(&values, GOLEM_MOONBIT_SDK_VERSION),
+            go_sdk_path: resolved_path_override(
+                &values,
+                GOLEM_GO_PATH,
+                golem_path.as_deref(),
+                "sdks/go/golem",
+            )?,
+            go_sdk_version: get_normalized_value_by_key(&values, GOLEM_GO_VERSION),
         })
     }
 
@@ -353,6 +403,12 @@ impl SdkOverrides {
         if let Some(value) = &self.moonbit_sdk_version {
             values.insert(GOLEM_MOONBIT_SDK_VERSION.to_string(), value.clone());
         }
+        if let Some(value) = &self.go_sdk_path {
+            values.insert(GOLEM_GO_PATH.to_string(), value.clone());
+        }
+        if let Some(value) = &self.go_sdk_version {
+            values.insert(GOLEM_GO_VERSION.to_string(), value.clone());
+        }
         values
     }
 
@@ -646,6 +702,8 @@ mod tests {
             scala_sdk_version: None,
             moonbit_sdk_path: None,
             moonbit_sdk_version: None,
+            go_sdk_path: None,
+            go_sdk_version: None,
         };
 
         assert_eq!(
@@ -665,6 +723,8 @@ mod tests {
             scala_sdk_version: None,
             moonbit_sdk_path: None,
             moonbit_sdk_version: None,
+            go_sdk_path: None,
+            go_sdk_version: None,
         }
         .to_env_vars();
 
diff --git a/cli/golem-cli/src/versions.rs b/cli/golem-cli/src/versions.rs
index c9c6ff4e86..40ca42a04e 100644
--- a/cli/golem-cli/src/versions.rs
+++ b/cli/golem-cli/src/versions.rs
@@ -17,6 +17,7 @@ pub mod sdk {
     pub const TS: &str = "1.1.1";
     pub const SCALA: &str = "1.5.1";
     pub const MOONBIT: &str = "0.5.2";
+    pub const GO: &str = "0.1.0";
     pub const MANIFEST: &str = "1.6.0";
 
     #[macro_export]
@@ -36,6 +37,16 @@ pub mod build_tool {
     pub const MOON_MIN: &str = "0.1.20260409";
     pub const JAVA_MIN: &str = "17.0.0";
     pub const WASM_TOOLS_MIN: &str = "1.227.1";
+    pub const GO_MIN: &str = "1.25.5";
+}
+
+// Keep this aligned with the Go component template's `tool` directive.
+//
+// componentize-go must be pinned to a concrete version, never `latest`: below
+// v0.4.0 the Go wrapper resolves its Rust binary from a *canary* channel and
+// silently ignores the pin.
+pub mod go_dep {
+    pub const COMPONENTIZE_GO: &str = "v0.4.0";
 }
 
 // Keep this aligned with the TS component template
diff --git a/cli/golem-cli/templates/go/common-on-demand/golem.yaml b/cli/golem-cli/templates/go/common-on-demand/golem.yaml
new file mode 100644
index 0000000000..a514d6ed6b
--- /dev/null
+++ b/cli/golem-cli/templates/go/common-on-demand/golem.yaml
@@ -0,0 +1,42 @@
+# golem-app-manifest-header
+
+componentTemplates:
+  go:
+    presets:
+      # debug keeps the name/DWARF custom sections for better diagnostics.
+      # Dependency resolution (go mod tidy) is NOT a build step: the CLI runs it
+      # automatically before the build, like `npm install` (see
+      # ensure_common_deps_for_tool).
+      debug:
+        default: true
+        build:
+        - command: go tool componentize-go build -o "{{ golemTempDir }}/agents/{{ component_name | to_snake_case }}.wasm"
+          dir: "{{ componentDir }}"
+          mkdirs:
+          - "{{ golemTempDir }}/agents"
+          sources:
+          - "{{ componentDir }}"
+          targets:
+          - "{{ golemTempDir }}/agents/{{ component_name | to_snake_case }}.wasm"
+        componentWasm: "{{ golemTempDir }}/agents/{{ component_name | to_snake_case }}.wasm"
+      # release strips the `name` custom sections (Go function names, ~2% of the
+      # component) for a smaller artifact that ships no internal symbol names,
+      # while keeping component-name/producers metadata the platform uses.
+      # componentize-go exposes no optimization levels, so this is the real
+      # debug/release difference.
+      release:
+        build:
+        - command: go tool componentize-go build -o "{{ golemTempDir }}/agents/{{ component_name | to_snake_case }}.debug.wasm"
+          dir: "{{ componentDir }}"
+          mkdirs:
+          - "{{ golemTempDir }}/agents"
+          sources:
+          - "{{ componentDir }}"
+          targets:
+          - "{{ golemTempDir }}/agents/{{ component_name | to_snake_case }}.debug.wasm"
+        - command: wasm-tools strip -d '^name$' "{{ golemTempDir }}/agents/{{ component_name | to_snake_case }}.debug.wasm" -o "{{ golemTempDir }}/agents/{{ component_name | to_snake_case }}.wasm"
+          sources:
+          - "{{ golemTempDir }}/agents/{{ component_name | to_snake_case }}.debug.wasm"
+          targets:
+          - "{{ golemTempDir }}/agents/{{ component_name | to_snake_case }}.wasm"
+        componentWasm: "{{ golemTempDir }}/agents/{{ component_name | to_snake_case }}.wasm"
diff --git a/cli/golem-cli/templates/go/common-on-demand/metadata.json b/cli/golem-cli/templates/go/common-on-demand/metadata.json
new file mode 100644
index 0000000000..af7fc9fa61
--- /dev/null
+++ b/cli/golem-cli/templates/go/common-on-demand/metadata.json
@@ -0,0 +1,4 @@
+{
+  "type": "common-on-demand",
+  "description": "On demand common template for Go Agents"
+}
diff --git a/cli/golem-cli/templates/go/common/.gitignore b/cli/golem-cli/templates/go/common/.gitignore
new file mode 100644
index 0000000000..70a62f3d27
--- /dev/null
+++ b/cli/golem-cli/templates/go/common/.gitignore
@@ -0,0 +1,4 @@
+*.wasm
+golem-temp/
+.golem/
+.golem-local/
diff --git a/cli/golem-cli/templates/go/common/AGENTS.md b/cli/golem-cli/templates/go/common/AGENTS.md
new file mode 100644
index 0000000000..9609a816b1
--- /dev/null
+++ b/cli/golem-cli/templates/go/common/AGENTS.md
@@ -0,0 +1,178 @@
+<!-- golem-managed:guide:go:start -->
+<!-- Golem manages this section. Do not edit manually. -->
+
+# Skills
+
+This project includes coding-agent skills in `.agents/skills/`. Load a skill when the task matches its description.
+
+**Activation cues for `golem.yaml` edits**: whenever a task involves editing `golem.yaml`, load `golem-edit-manifest` for the manifest schema, and also load the section-specific skill — `golem-add-env-vars` for `env`/`envDefaults`/`secretDefaults` changes, `golem-add-initial-files` for `files:` blocks, `golem-profiles-and-environments` for `presets`/environment-scoped sections, `golem-manage-plugins` for `plugins:` entries, `golem-configure-api-domain` for `httpApi`, and `golem-configure-mcp-server` for `mcp`.
+
+| Skill | Description |
+|-------|-------------|
+| `golem-cloud-account-setup` | Setting up a Golem Cloud account — authentication, cloud profiles, API tokens, and first cloud deployment |
+| `golem-new-project` | Creating a new Golem application project with `golem new` |
+| `golem-add-component` | Adding a new component or agent templates to an existing application |
+| `golem-edit-manifest` | Editing the Golem Application Manifest (golem.yaml) — components, agents, templates, environments, httpApi, mcp, bridge SDKs, plugins, and more |
+| `golem-build` | Building a Golem application with `golem build` |
+| `golem-troubleshoot-build` | Troubleshooting Golem build failures and debugging manifest file (golem.yaml) configuration — diagnosing tool, dependency, env var, config, and manifest layer issues with `golem component manifest-trace` |
+| `golem-deploy` | Deploying a Golem application with `golem deploy` |
+| `golem-local-dev-server` | Starting, configuring, and debugging the local Golem development server with `golem server` — verbosity flags, useful tracing targets, and key log lines |
+| `golem-rollback` | Rolling back a Golem deployment to a previous revision or version |
+| `golem-redeploy-agents` | Redeploying existing agents by deleting and recreating them |
+| `golem-configure-api-domain` | Configuring HTTP API domain deployments and security schemes in golem.yaml |
+| `golem-configure-mcp-server` | Configuring MCP (Model Context Protocol) server deployments in golem.yaml |
+| `golem-manage-plugins` | Managing Golem plugins — listing available plugins, installing and configuring plugins via golem.yaml or CLI, and understanding built-in plugins like the OTLP exporter |
+| `golem-profiles-and-environments` | Understanding CLI profiles, app environments, and component presets — switching between local/cloud, managing deployment targets, and activating per-environment configuration |
+| `golem-add-env-vars` | Defining environment variables for agents in golem.yaml and via CLI |
+| `golem-add-initial-files` | Adding initial files to agent filesystems via golem.yaml |
+| `golem-view-agent-logs` | Viewing agent logs and output via streaming |
+| `golem-view-agent-files` | Listing files in an agent's virtual filesystem |
+| `golem-list-and-filter-agents` | Listing and querying agents with filters |
+| `golem-get-agent-metadata` | Checking agent metadata and status |
+| `golem-debug-agent-history` | Querying the operation log |
+| `golem-undo-agent-state` | Reverting agent state by undoing operations |
+| `golem-interrupt-resume-agent` | Interrupting and resuming a Golem agent |
+| `golem-test-crash-recovery` | Simulating a crash on an agent for testing crash recovery |
+| `golem-integration-test-setup` | Setting up a dedicated Golem environment for integration testing — isolated local server, test environment in golem.yaml, dynamic port discovery, and non-interactive deploys |
+| `golem-cancel-queued-invocation` | Canceling a pending (queued) invocation on an agent |
+| `golem-delete-agent` | Deleting an agent instance |
+
+> **Go support is new.** Go-specific skills (`golem-add-agent-go`, `golem-add-http-endpoint-go`, …)
+> are not available yet, so only the common skills are listed above. Until they land, use the Go SDK's
+> own documentation.
+
+# Golem Application Development Guide (Go)
+
+## Overview
+
+This is a **Golem Application** — a distributed computing project targeting WebAssembly (WASM). Components are compiled to WASM components with `componentize-go` and executed on the Golem platform, which provides durable execution, persistent state, and agent-to-agent communication.
+
+Key concepts:
+- **Component**: A WASM component compiled from Go, defining one or more agent types
+- **Agent type**: A struct annotated with `#derive.agent`, defining the agent's API via its public methods
+- **Agent (worker)**: A running instance of an agent type, identified by constructor parameters, with persistent state
+
+## Agent Fundamentals
+
+- Every agent is uniquely identified by its **constructor parameter values** — two agents with the same parameters are the same agent
+- Agents are **durable by default** — their state persists across invocations, failures, and restarts
+- Invocations are processed **sequentially in a single thread** — no concurrency within a single agent, no need for locks
+- Agents can **spawn other agents** and communicate with them via **RPC** (see Agent-to-Agent Communication)
+- An agent is created implicitly on first invocation — no separate creation step needed
+- **Async handles cannot outlive invocations** — every WASI `pollable` or `future-*` resource (e.g. those returned by `@http.handle`) must be subscribed to / `get()`-ed within the same invocation; do not store unresolved pollables or futures in agent state to consume them from a later invocation
+
+## Durability & Automatic Retries
+
+Golem **automatically retries** failed operations using durable execution. **Do not add manual retry loops, `match` + retry patterns, or backoff utilities in agent code** — let operations fail and Golem will retry them. A built-in default policy (3 retries, exponential backoff with jitter, clamped to [100ms, 1s]) applies when no user-defined policy matches.
+
+The following are retried transparently:
+
+- **HTTP requests** to external services (via `wasi:http` and friends)
+- **RPC calls** between agents
+- **Database / storage calls** — `golem:rdbms/postgres`, `golem:rdbms/mysql`, `golem:rdbms/ignite2`, `wasi:blobstore`, `wasi:keyvalue`
+- **Panics and unhandled errors** (raised via `raise` or propagated with `!`) escaping an agent method — the worker is restarted and the invocation is replayed from the oplog, with all previously-recorded side effects skipped
+
+Only customize when the *strategy* needs to change (different backoff, give-up conditions, per-status-code policies). For that, see the Go SDK's retry-policy helpers.
+
+## Project Structure
+
+```
+golem.yaml                        # Root application manifest
+<component>/                      # Component directory (each becomes a WASM component)
+  golem.yaml                      # Component manifest
+  go.mod                          # This component's module; pins the SDK and componentize-go
+  main.go                         # package main — blank-imports the SDK + each agent package
+  counter/                        # One package per agent
+    counter.go                    #   package counter — agent definition + init() registration
+golem-temp/                       # Build artifacts (gitignored)
+```
+
+Each component directory is **its own Go module** (its own `go.mod`), built to a separate WASM
+component. Within a component, every agent lives in its own package (`counter/counter.go` is
+`package counter`), and a single `main.go` (`package main`) blank-imports the SDK and each agent
+package so their `init()` functions register the agents — the same blank-import-for-side-effects
+pattern Go uses to register database drivers (`import _ "..."`). Adding an agent means adding a package
+and a blank import to `main.go`.
+
+## Prerequisites
+
+- Go toolchain: https://go.dev/dl/ (Go 1.25.5 or newer)
+- Golem CLI (`golem`) version 1.5.x: https://github.com/golemcloud/golem/releases
+- `wasm-tools`: https://github.com/bytecodealliance/wasm-tools
+
+## Name Mapping
+
+Wire names come from the SDK's declarations, not from Go identifiers:
+
+- **Agent type names**: the `Name` in `golem.Spec{Name: "CounterAgent"}`
+- **Method names**: the string passed to `golem.DefineMethod[...]("increment")`
+- **Parameter and record field names**: the Go field name **lower-camel-cased** — `AmountCents` → `amountCents`
+- **Variant case names**: the string in `golem.Case[Card]("card")`
+- **Enum case names**: positional, from `golem.DefineEnum[Status]("active", "closed")`
+
+## Key Constraints
+
+- Target is **WASM only** — no raw sockets. `net.Dial`, most database drivers and custom gRPC
+  transports cannot work; outgoing HTTP goes through the SDK's WASI-backed transport.
+- Bare `int`/`uint` are **rejected** at registration: their width is platform-dependent, so the wire
+  type would be ambiguous. Use `int64`/`uint64` or another sized type.
+- A `*T` field means `option<T>`. A nil slice or map is an **empty** list/map, never "absent" — spell
+  the optional container `*[]T` if you need to distinguish.
+- Method descriptors must be **package-level vars**: the same value drives the schema, the
+  implementation binding and cross-agent calls.
+- Cross-agent calls hang off the descriptor (`Charge.Call(client, in)`), because Go methods cannot
+  introduce type parameters.
+- `main.go` (`package main`) holds an empty `func main() {}` plus a blank import of each agent
+  package. The blank `_ "github.com/golemcloud/golem/sdks/go/golem"` import must stay — it initializes
+  the SDK runtime (e.g. HTTP) and links the component exports; do not remove it even though it looks
+  unused.
+- Multiple agents can coexist in one component (each its own package, all blank-imported by `main.go`);
+  a worker is initialized as exactly one of them.
+- **Environment variables** use the standard library — `os.Getenv` / `os.Environ` read the worker's
+  environment with no special setup (they route to `wasi:cli/environment` via the toolchain's WASI
+  adapter). Alongside any vars you set (`env:` in `golem.yaml`, or `golem agent new --env`), the runtime
+  injects `GOLEM_AGENT_ID`, `GOLEM_WORKER_NAME`, `GOLEM_COMPONENT_ID`, `GOLEM_COMPONENT_REVISION` and
+  `GOLEM_AGENT_TYPE`.
+- **Logging** uses the standard library — the SDK installs an `slog` handler on startup that routes
+  `slog` (and, via slog, the standard `log` package) through the host logging channel, so records carry a
+  real level and context in worker logs (`slog.Info(...)` → an `INFO` event, `slog.Warn`/`Error`
+  likewise). Plain `fmt.Println` / direct `os.Stdout`/`os.Stderr` writes are still captured, but as raw
+  stdout/stderr with no level. Tune it with `golem/log`'s `SetDefault(&log.Options{Level: ...})`; view
+  output with the `golem-view-agent-logs` skill.
+- Do NOT edit files under `internal/wit/` in the SDK — they are generated.
+
+## Coding Convention
+
+- Standard Go style: `gofmt` decides formatting; `UpperCamelCase` for exported identifiers,
+  `lowerCamelCase` otherwise.
+- Agents are declared with `golem.DefineAgent`, methods with `golem.DefineMethod`, and behaviour
+  bound with `golem.Implement` in an `init()`.
+- Handlers may be plain closures or ordinary Go methods bound with a method expression
+  (`golem.Bind((*CartState).AddItem)`).
+
+## Tooling
+
+- `gofmt -w .` — format code
+- `go vet ./...` — static checks
+- `go test ./...` — run tests
+- `golem app build` — build the components (runs `go tool componentize-go build`)
+
+## Running Golem CLI commands non-interactively
+
+The `golem` CLI prompts for confirmation when it needs to apply changes such as syncing project skill files, updating dependency configurations, or recreating deployments. In non-interactive contexts (CI, scripts, coding agents) **always pass `--yes` (or `-y`) to mutating commands** so the CLI auto-confirms instead of aborting:
+
+```shell
+golem build --yes
+golem deploy --yes
+golem new --yes --template <LANGUAGE> <APPLICATION_PATH>
+golem agent update --yes <AGENT>
+```
+
+If you see `This action requires confirmation, but the current shell is non-interactive.` (older CLI versions: `The current input device is not an interactive one, defaulting to "false"`) followed by `Failed to build application`, re-run the same command with `--yes`.
+
+## Documentation
+
+- Golem docs: https://learn.golem.cloud
+- Go docs: https://go.dev/doc/
+- App manifest reference: https://learn.golem.cloud/app-manifest
+<!-- golem-managed:guide:go:end -->
diff --git a/cli/golem-cli/templates/go/common/golem.yaml b/cli/golem-cli/templates/go/common/golem.yaml
new file mode 100644
index 0000000000..f544cbf0b2
--- /dev/null
+++ b/cli/golem-cli/templates/go/common/golem.yaml
@@ -0,0 +1,24 @@
+# golem-app-manifest-header
+
+manifestVersion: golem-manifest-version
+
+app: app-name
+
+version:
+  git:
+    tagPattern: "v*"
+    hashFallback: true
+    staticFallback: "v0.0.0"
+
+environments:
+  local:
+    server: local
+    componentPresets: debug
+    version:
+      git:
+        allowDirty: true
+  cloud:
+    server: cloud
+    componentPresets: release
+    deployment:
+      versionCheck: true
diff --git a/cli/golem-cli/templates/go/common/metadata.json b/cli/golem-cli/templates/go/common/metadata.json
new file mode 100644
index 0000000000..385bab0f72
--- /dev/null
+++ b/cli/golem-cli/templates/go/common/metadata.json
@@ -0,0 +1,4 @@
+{
+  "type": "common",
+  "description": "Common template for Go Agents"
+}
diff --git a/cli/golem-cli/templates/go/component/component-dir/go.mod._ b/cli/golem-cli/templates/go/component/component-dir/go.mod._
new file mode 100644
index 0000000000..1a1be1acad
--- /dev/null
+++ b/cli/golem-cli/templates/go/component/component-dir/go.mod._
@@ -0,0 +1,20 @@
+// Each Go component is its OWN module, with go.mod in the component directory.
+//
+// This is required, not stylistic: componentize-go discovers the SDK's WIT by
+// scanning the module and its dependencies for componentize-go.toml, and that
+// scan only resolves when it runs from the module root. A single app-level
+// module would fail with "failed to read path for WIT".
+module component-name
+
+go GOLEM_GO_DEP_GO_VERSION
+
+require (
+	GOLEM_GO_DEP_SDK_MODULE GOLEM_GO_DEP_SDK_VERSION
+	github.com/bytecodealliance/componentize-go GOLEM_GO_DEP_COMPONENTIZE_GO_VERSION
+)
+
+// componentize-go is pinned per-app through this directive rather than installed
+// globally, so `go tool componentize-go` always runs the version this app was
+// built against.
+tool github.com/bytecodealliance/componentize-go
+GOLEM_GO_DEP_SDK_REPLACE
diff --git a/cli/golem-cli/templates/go/component/component-dir/main.go b/cli/golem-cli/templates/go/component/component-dir/main.go
new file mode 100644
index 0000000000..7e13585d82
--- /dev/null
+++ b/cli/golem-cli/templates/go/component/component-dir/main.go
@@ -0,0 +1,10 @@
+package main
+
+// The blank import initializes the Golem SDK runtime (for example, routing
+// net/http through the platform); keep it even though it looks unused. Each
+// agent package below registers itself on import, and main stays empty.
+import (
+	_ "github.com/golemcloud/golem/sdks/go/golem"
+)
+
+func main() {}
diff --git a/cli/golem-cli/templates/go/component/golem.yaml b/cli/golem-cli/templates/go/component/golem.yaml
new file mode 100644
index 0000000000..8b5f84a43c
--- /dev/null
+++ b/cli/golem-cli/templates/go/component/golem.yaml
@@ -0,0 +1,6 @@
+# golem-app-manifest-header
+
+components:
+  componentname:
+    dir: "componentDir"
+    templates: go
diff --git a/cli/golem-cli/templates/go/component/metadata.json b/cli/golem-cli/templates/go/component/metadata.json
new file mode 100644
index 0000000000..3b27f1d60e
--- /dev/null
+++ b/cli/golem-cli/templates/go/component/metadata.json
@@ -0,0 +1,4 @@
+{
+  "type": "component",
+  "description": "Go component"
+}
diff --git a/cli/golem-cli/templates/go/default/component-dir/counter/counter.go b/cli/golem-cli/templates/go/default/component-dir/counter/counter.go
new file mode 100644
index 0000000000..1792d5a838
--- /dev/null
+++ b/cli/golem-cli/templates/go/default/component-dir/counter/counter.go
@@ -0,0 +1,60 @@
+// Counter agent in Go. Each agent lives in its own package; main.go blank-imports
+// this package so its init() registers the agent with the SDK.
+package counter
+
+import "github.com/golemcloud/golem/sdks/go/golem"
+
+// CounterID holds the agent's constructor parameters, and doubles as the
+// type-level identity used by typed cross-agent calls.
+type CounterID struct{ Name string }
+
+// CounterState is the agent's private, durable state.
+type CounterState struct{ value int64 }
+
+// AddIn is a method's parameter list: one WIT parameter per exported field.
+type AddIn struct{ By int64 }
+
+var Counter = golem.DefineAgent[CounterID, CounterState](
+	golem.Spec{
+		Name:        "CounterAgent",
+		Description: "A simple durable counter",
+		Mode:        golem.Durable,
+	},
+	func(id CounterID) *CounterState { return &CounterState{} },
+)
+
+// Method descriptors are package-level vars on purpose: the same value drives
+// the published schema, the implementation below, and calls from other agents.
+var (
+	Increment = golem.DefineMethod[CounterID, golem.Unit, int64](
+		"increment",
+		golem.Desc("Increase the count by one"),
+	)
+	Add = golem.DefineMethod[CounterID, AddIn, int64](
+		"add",
+		golem.Desc("Add to the count"),
+	)
+	Value = golem.DefineMethod[CounterID, golem.Unit, int64](
+		"value",
+		golem.Desc("Return the current value"),
+	)
+)
+
+func init() {
+	// Handlers return only their output value; signal failure by panicking (the
+	// SDK recovers it into an agent-error). Model expected outcomes as a Result.
+	golem.Implement(Counter, Increment, func(ctx *golem.Context[CounterState], _ golem.Unit) int64 {
+		ctx.State.value++
+		return ctx.State.value
+	})
+
+	golem.Implement(Counter, Add, func(ctx *golem.Context[CounterState], in AddIn) int64 {
+		ctx.State.value += in.By
+		return ctx.State.value
+	})
+
+	// A handler can also be an ordinary Go method, bound with a method expression.
+	golem.Implement(Counter, Value, golem.Bind0((*CounterState).current))
+}
+
+func (s *CounterState) current() int64 { return s.value }
diff --git a/cli/golem-cli/templates/go/default/component-dir/main.go b/cli/golem-cli/templates/go/default/component-dir/main.go
new file mode 100644
index 0000000000..66606de1f8
--- /dev/null
+++ b/cli/golem-cli/templates/go/default/component-dir/main.go
@@ -0,0 +1,3 @@
+package main
+
+import _ "component-name/counter"
diff --git a/cli/golem-cli/templates/go/default/metadata.json b/cli/golem-cli/templates/go/default/metadata.json
new file mode 100644
index 0000000000..cdf6621c3c
--- /dev/null
+++ b/cli/golem-cli/templates/go/default/metadata.json
@@ -0,0 +1,4 @@
+{
+  "type": "agent",
+  "description": "A simple agent implementing a counter"
+}
diff --git a/cli/golem-cli/templates/go/snapshotting/component-dir/main.go b/cli/golem-cli/templates/go/snapshotting/component-dir/main.go
new file mode 100644
index 0000000000..44ce7ba6bd
--- /dev/null
+++ b/cli/golem-cli/templates/go/snapshotting/component-dir/main.go
@@ -0,0 +1,3 @@
+package main
+
+import _ "component-name/session"
diff --git a/cli/golem-cli/templates/go/snapshotting/component-dir/session/session.go b/cli/golem-cli/templates/go/snapshotting/component-dir/session/session.go
new file mode 100644
index 0000000000..06e2800a9b
--- /dev/null
+++ b/cli/golem-cli/templates/go/snapshotting/component-dir/session/session.go
@@ -0,0 +1,60 @@
+// Session agent in Go. It shows how to control state snapshotting: the SDK asks
+// the guest to serialize durable state periodically (and on upgrade), so custom
+// serialization is worth demonstrating alongside the default.
+package session
+
+import "github.com/golemcloud/golem/sdks/go/golem"
+
+// SessionID identifies the session agent by its constructor parameters.
+type SessionID struct{ User string }
+
+// SessionState keeps a running total in an unexported field. Reflection cannot
+// see unexported fields, so the default (JSON of exported fields) would drop it;
+// implementing Snapshotter below is what makes the state survive a snapshot.
+type SessionState struct{ total int64 }
+
+// Save/Load make SessionState a golem.Snapshotter: the returned bytes are stored
+// verbatim by the host and handed back on restore, so unexported state is kept.
+func (s *SessionState) Save() ([]byte, error) { return []byte{byte(s.total)}, nil }
+func (s *SessionState) Load(b []byte) error {
+	if len(b) > 0 {
+		s.total = int64(b[0])
+	}
+	return nil
+}
+
+// SpendIn is the parameter list for the spend method.
+type SpendIn struct{ Amount int64 }
+
+var Session = golem.DefineAgent[SessionID, SessionState](
+	golem.Spec{
+		Name:        "SessionAgent",
+		Description: "A session that snapshots its running total every few invocations",
+		Mode:        golem.Durable,
+		// Snapshot the state every 5 invocations instead of the default cadence.
+		Snapshot: golem.SnapshotEveryN(5),
+	},
+	func(id SessionID) *SessionState { return &SessionState{} },
+)
+
+var (
+	Spend = golem.DefineMethod[SessionID, SpendIn, int64](
+		"spend",
+		golem.Desc("Add to the running total"),
+	)
+	Total = golem.DefineMethod[SessionID, golem.Unit, int64](
+		"total",
+		golem.Desc("Return the running total"),
+	)
+)
+
+func init() {
+	golem.Implement(Session, Spend, func(ctx *golem.Context[SessionState], in SpendIn) int64 {
+		ctx.State.total += in.Amount
+		return ctx.State.total
+	})
+
+	golem.Implement(Session, Total, func(ctx *golem.Context[SessionState], _ golem.Unit) int64 {
+		return ctx.State.total
+	})
+}
diff --git a/cli/golem-cli/templates/go/snapshotting/metadata.json b/cli/golem-cli/templates/go/snapshotting/metadata.json
new file mode 100644
index 0000000000..eabc774d23
--- /dev/null
+++ b/cli/golem-cli/templates/go/snapshotting/metadata.json
@@ -0,0 +1,4 @@
+{
+  "type": "agent",
+  "description": "An agent that customizes state snapshotting"
+}
diff --git a/cli/golem-cli/tests/app/agents.rs b/cli/golem-cli/tests/app/agents.rs
index 5b0ab23cd7..38c595ce90 100644
--- a/cli/golem-cli/tests/app/agents.rs
+++ b/cli/golem-cli/tests/app/agents.rs
@@ -76,6 +76,95 @@ async fn test_rust_counter() {
     }
 }
 
+/// End-to-end test for the Go SDK: creates a Go app from the composable counter
+/// template, adds a second agent package via the snapshotting template (proving
+/// the merged main.go barrel deploys and runs, not just compiles), then deploys
+/// and invokes methods on both agents against a live local server. This is the
+/// CLI-driven integration layer for the Go SDK — the wasi-touching RPC/host path
+/// only links and runs on wasm, so it is covered here rather than by `go test`.
+///
+/// Requires the Go toolchain + componentize-go on the PATH.
+#[test]
+#[timeout("15 minutes")]
+async fn test_go_counter() {
+    let mut ctx = TestContext::new();
+    let app_name = "counter";
+    let component_name = "counter:svc";
+
+    ctx.start_server().await;
+
+    let outputs = ctx
+        .cli([
+            flag::YES,
+            cmd::NEW,
+            app_name,
+            flag::COMPONENT_NAME,
+            component_name,
+            flag::TEMPLATE,
+            "go",
+        ])
+        .await;
+    assert!(outputs.success_or_dump());
+
+    ctx.cd(app_name);
+
+    // Compose a second agent (its own package) into the same component, so the
+    // merged main.go barrel is exercised at runtime.
+    let outputs = ctx
+        .cli([
+            flag::YES,
+            cmd::NEW,
+            ".",
+            flag::COMPONENT_NAME,
+            component_name,
+            flag::TEMPLATE,
+            "go/snapshotting",
+        ])
+        .await;
+    assert!(outputs.success_or_dump());
+
+    let outputs = ctx.cli([cmd::DEPLOY, flag::YES]).await;
+    assert!(outputs.success_or_dump());
+
+    // CounterAgent: increment -> 1, add 5 -> 6, value -> 6.
+    let counter = format!("CounterAgent(\"{}\")", Uuid::new_v4());
+
+    let outputs = ctx
+        .cli([flag::YES, cmd::AGENT, cmd::INVOKE, &counter, "increment"])
+        .await;
+    assert!(outputs.success_or_dump());
+    assert!(!outputs.stderr_contains("error"));
+    assert!(outputs.stdout_contains_ordered(["Invocation result", "1"]));
+
+    let outputs = ctx
+        .cli([flag::YES, cmd::AGENT, cmd::INVOKE, &counter, "add", "5"])
+        .await;
+    assert!(outputs.success_or_dump());
+    assert!(outputs.stdout_contains_ordered(["Invocation result", "6"]));
+
+    let outputs = ctx
+        .cli([flag::YES, cmd::AGENT, cmd::INVOKE, &counter, "value"])
+        .await;
+    assert!(outputs.success_or_dump());
+    assert!(outputs.stdout_contains_ordered(["Invocation result", "6"]));
+
+    // SessionAgent (from the snapshotting template): spend 10 -> 10, total -> 10.
+    // Invoking it at all proves the composed second package registered and runs.
+    let session = format!("SessionAgent(\"{}\")", Uuid::new_v4());
+
+    let outputs = ctx
+        .cli([flag::YES, cmd::AGENT, cmd::INVOKE, &session, "spend", "10"])
+        .await;
+    assert!(outputs.success_or_dump());
+    assert!(outputs.stdout_contains_ordered(["Invocation result", "10"]));
+
+    let outputs = ctx
+        .cli([flag::YES, cmd::AGENT, cmd::INVOKE, &session, "total"])
+        .await;
+    assert!(outputs.success_or_dump());
+    assert!(outputs.stdout_contains_ordered(["Invocation result", "10"]));
+}
+
 /// End-to-end test for the Scala bridge generator: deploys the Rust counter
 /// agent, generates a Scala bridge SDK for it, then compiles and runs a small
 /// Scala program that invokes the live agent through the generated, future-based
diff --git a/cli/golem-cli/tests/app/build_and_deploy_all.rs b/cli/golem-cli/tests/app/build_and_deploy_all.rs
index 0bd9cb57b3..ec1cb18edf 100644
--- a/cli/golem-cli/tests/app/build_and_deploy_all.rs
+++ b/cli/golem-cli/tests/app/build_and_deploy_all.rs
@@ -241,6 +241,23 @@ fn assert_multi_component_layout(app_root: &std::path::Path, language: GuestLang
                 "expected multi-component MoonBit layout: moon.mod.json should remain at the app root"
             );
         }
+        GuestLanguage::Go => {
+            // Unlike Scala/MoonBit, NOTHING stays behind: each Go component is
+            // its own module, and componentize-go only resolves the SDK's WIT
+            // when it runs from a module root.
+            assert!(
+                !app_root.join("go.mod").exists(),
+                "expected multi-component Go layout: go.mod should no longer be at the app root"
+            );
+            let has_go_at_root = std::fs::read_dir(app_root)
+                .unwrap()
+                .filter_map(|e| e.ok())
+                .any(|e| e.path().extension().and_then(|x| x.to_str()) == Some("go"));
+            assert!(
+                !has_go_at_root,
+                "expected multi-component Go layout: no *.go files should remain at the app root"
+            );
+        }
         _ => {}
     }
 }
diff --git a/dev-tools/Cargo.lock b/dev-tools/Cargo.lock
index 6577455adb..c7040f6176 100644
--- a/dev-tools/Cargo.lock
+++ b/dev-tools/Cargo.lock
@@ -5,3 +5,7 @@ version = 4
 [[package]]
 name = "dir-mirror"
 version = "0.0.0"
+
+[[package]]
+name = "go-bindgen-fixup"
+version = "0.0.0"
diff --git a/dev-tools/Cargo.toml b/dev-tools/Cargo.toml
index c5c438964a..97007388ea 100644
--- a/dev-tools/Cargo.toml
+++ b/dev-tools/Cargo.toml
@@ -4,4 +4,4 @@
 # Add more tool crates as members.
 [workspace]
 resolver = "2"
-members = ["dir-mirror"]
+members = ["dir-mirror", "go-bindgen-fixup"]
diff --git a/dev-tools/README.md b/dev-tools/README.md
index 247d9c6c8d..c87ccae828 100644
--- a/dev-tools/README.md
+++ b/dev-tools/README.md
@@ -29,6 +29,12 @@ main workspace.
 
 ## Tools
 
+- **`go-bindgen-fixup`** — post-processes the generated Go SDK bindings (`sdks/go/internal/wit`)
+  to work around a `wit-bindgen` `crates/go` codegen bug: variant case tag constants are named
+  `<Variant><Case>`, which collides with the record type generated from a WIT record named
+  `<variant>-<case>` (golem's `queued-card-event`), producing Go that does not compile. Renames
+  the colliding *constant* to `<Name>Tag`. Collision detection is generic, not hardcoded. Invoked
+  by `sdks/go/scripts/generate-bindings.sh`; **delete once fixed upstream**.
 - **`dir-mirror`** — idempotent directory mirror: makes a destination directory a
   byte-identical copy of a source directory, rewriting only changed files (preserving
   mtimes) and pruning stale ones. Used by the `wit` task to sync the per-crate
diff --git a/dev-tools/go-bindgen-fixup/Cargo.toml b/dev-tools/go-bindgen-fixup/Cargo.toml
new file mode 100644
index 0000000000..ab3434f35d
--- /dev/null
+++ b/dev-tools/go-bindgen-fixup/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "go-bindgen-fixup"
+version = "0.0.0"
+edition = "2024"
+license-file = "../../LICENSE"
+publish = false
+description = "Works around a wit-bindgen crates/go codegen bug in the generated Go SDK bindings"
+
+# No dependencies — std only, on purpose (see dev-tools/README.md). Tests use plain
+# `cargo test` (libtest), so there are no dev-dependencies either.
+
+[[bin]]
+name = "go-bindgen-fixup"
+test = false
diff --git a/dev-tools/go-bindgen-fixup/src/lib.rs b/dev-tools/go-bindgen-fixup/src/lib.rs
new file mode 100644
index 0000000000..e3017e1d32
--- /dev/null
+++ b/dev-tools/go-bindgen-fixup/src/lib.rs
@@ -0,0 +1,462 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// Licensed under the Golem Source License v1.1 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://license.golem.cloud/LICENSE
+//
+// 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.
+
+//! Post-process Go bindings generated by `wit-bindgen`'s `crates/go` backend, working
+//! around codegen bugs that produce Go which does not compile.
+//!
+//! Two independent fixups are applied; both are upstream bugs and both should be deleted
+//! from here once fixed upstream (see `tmp/plan` → "Upstream candidates").
+//!
+//! # 1. Variant tag constants colliding with record types
+//!
+//! **The bug** (wit-bindgen 0.58.0): a variant's case tag constants are named
+//! `<Variant><Case>`, which collides with the record type generated for a WIT record
+//! named `<variant>-<case>`. Golem's WIT uses exactly that convention:
+//!
+//! ```wit
+//! record  queued-card-event-install { card-id: card-id }
+//! variant queued-card-event { install(queued-card-event-install), ... }
+//! ```
+//!
+//! which generates both `type QueuedCardEventInstall struct` and
+//! `const QueuedCardEventInstall uint8 = 0`, so Go rejects the package with
+//! "X redeclared in this block" and "X (type) is not an expression".
+//!
+//! `golem:api/oplog` (where this occurs) is pulled in transitively via
+//! `golem:durability`, so it cannot be avoided by trimming the world.
+//!
+//! **The fix**: rename the colliding *constant* to `<Name>Tag` and update the four call
+//! shapes the generator emits. The record type keeps its name, so nothing user-facing
+//! changes.
+//!
+//! Collision detection is generic — declared struct type names are intersected with
+//! declared tag constants; no names are hardcoded.
+//!
+//! # 2. Missing `empty.s` in the exports package
+//!
+//! Go only allows a function declaration **without a body** if the package contains at
+//! least one `.s` file (the compiler assumes assembly supplies it). `//go:wasmimport`
+//! declarations are bodyless by nature, so the generator drops a small `empty.s` stub
+//! into each package — its own comment says it exists "for testing this package without
+//! WebAssembly".
+//!
+//! It emits that stub for *import* packages but **not** for the exports package, which
+//! nevertheless contains one bodyless `[task-return]` `//go:wasmimport` per async export.
+//! Without it, that package (and therefore anything importing the SDK) cannot be compiled
+//! for the host at all — which would rule out native `go test`.
+//!
+//! **The fix**: write the same stub into any package that has a `//go:wasmimport` but no
+//! `.s` file. Calling a host import on the host is still a *link* error naming the missing
+//! symbol, so the host/guest boundary stays enforced by the toolchain.
+
+use std::fs;
+use std::io;
+use std::path::{Path, PathBuf};
+
+pub const USAGE: &str = "Usage: go-bindgen-fixup <dir> [<dir> ...]\n\
+     \n\
+     Applies workarounds for wit-bindgen crates/go codegen bugs, recursively, in each\n\
+     <dir>:\n\
+     \n\
+     1. renames variant tag constants that collide with a struct type of the same\n\
+     name to <Name>Tag;\n\
+     2. adds the missing empty.s stub to any package that has a bodyless\n\
+     //go:wasmimport but no assembly file (without it the package cannot be\n\
+     compiled for the host, which would rule out native `go test`).";
+
+/// Integer types wit-bindgen uses for variant discriminants.
+const TAG_TYPES: [&str; 3] = ["uint8", "uint16", "uint32"];
+
+/// Names of struct types declared in `src` (`type Foo struct {`).
+fn struct_types(src: &str) -> Vec<&str> {
+    src.lines()
+        .filter_map(|line| {
+            let rest = line.strip_prefix("type ")?;
+            let (name, tail) = rest.split_once(' ')?;
+            tail.starts_with("struct {").then_some(name)
+        })
+        .collect()
+}
+
+/// Names of tag constants declared in `src` (`\tFoo uint8 = 0`, possibly gofmt-aligned
+/// with extra spaces).
+fn tag_constants(src: &str) -> Vec<&str> {
+    src.lines()
+        .filter_map(parse_tag_const)
+        .map(|(n, _, _)| n)
+        .collect()
+}
+
+/// Parse `\tName<ws>uintN = <digits>` into (name, int type, value).
+fn parse_tag_const(line: &str) -> Option<(&str, &str, &str)> {
+    if !line.starts_with('\t') {
+        return None;
+    }
+    // `split_whitespace` already skips leading/trailing whitespace.
+    let mut parts = line.split_whitespace();
+    let name = parts.next()?;
+    let int_ty = parts.next()?;
+    if !TAG_TYPES.contains(&int_ty) || parts.next()? != "=" {
+        return None;
+    }
+    let value = parts.next()?;
+    if parts.next().is_some() || value.is_empty() || !value.bytes().all(|b| b.is_ascii_digit()) {
+        return None;
+    }
+    Some((name, int_ty, value))
+}
+
+/// Rewrite `src`, renaming every tag constant whose name collides with a struct type.
+/// Returns the new source and the names that were renamed (sorted, deduplicated).
+pub fn fix_source(src: &str) -> (String, Vec<String>) {
+    let types = struct_types(src);
+    let mut collisions: Vec<String> = tag_constants(src)
+        .into_iter()
+        .filter(|c| types.contains(c))
+        .map(str::to_string)
+        .collect();
+    collisions.sort();
+    collisions.dedup();
+
+    if collisions.is_empty() {
+        return (src.to_string(), collisions);
+    }
+
+    let mut out = src.to_string();
+    for name in &collisions {
+        let tag = format!("{name}Tag");
+
+        // 1. the declaration inside the const block
+        out = out
+            .lines()
+            .map(|line| match parse_tag_const(line) {
+                Some((n, int_ty, value)) if n == name => format!("\t{tag} {int_ty} = {value}"),
+                _ => line.to_string(),
+            })
+            .collect::<Vec<_>>()
+            .join("\n");
+        if src.ends_with('\n') && !out.ends_with('\n') {
+            out.push('\n');
+        }
+
+        // 2..4: usages where the constant (not the type) is meant. Each pattern carries
+        // its own delimiter, so a longer identifier sharing this prefix cannot match.
+        out = out.replace(&format!(".tag != {name} {{"), &format!(".tag != {tag} {{"));
+        out = out.replace(&format!("{{{name}, "), &format!("{{{tag}, "));
+        out = out.replace(&format!("case {name}:"), &format!("case {tag}:"));
+    }
+    (out, collisions)
+}
+
+/// Byte-identical to the stub the generator writes into import packages (no trailing
+/// newline), so a fixed-up tree is indistinguishable from a correctly generated one.
+const EMPTY_S: &str = "// This file exists for testing this package without WebAssembly,\n\
+     // allowing empty function bodies with a //go:wasmimport directive.\n\
+     // See https://pkg.go.dev/cmd/compile for more information.";
+
+const EMPTY_S_NAME: &str = "empty.s";
+
+/// Does this package directory declare a `//go:wasmimport` (i.e. contain bodyless
+/// function declarations)? `//go:wasmexport` functions have bodies and do not count.
+fn needs_assembly_stub(dir: &Path) -> io::Result<bool> {
+    for entry in fs::read_dir(dir)? {
+        let path = entry?.path();
+        if path.extension().is_some_and(|e| e == "go")
+            && fs::read_to_string(&path)?.contains("//go:wasmimport")
+        {
+            return Ok(true);
+        }
+    }
+    Ok(false)
+}
+
+fn has_assembly_file(dir: &Path) -> io::Result<bool> {
+    for entry in fs::read_dir(dir)? {
+        if entry?.path().extension().is_some_and(|e| e == "s") {
+            return Ok(true);
+        }
+    }
+    Ok(false)
+}
+
+/// Write the `empty.s` stub into every package under `root` that needs one and lacks it.
+/// Returns the paths written.
+pub fn add_missing_assembly_stubs(root: &Path) -> io::Result<Vec<PathBuf>> {
+    let mut written = Vec::new();
+    let mut dirs = vec![root.to_path_buf()];
+    while let Some(dir) = dirs.pop() {
+        for entry in fs::read_dir(&dir)? {
+            let path = entry?.path();
+            if path.is_dir() {
+                dirs.push(path);
+            }
+        }
+        if needs_assembly_stub(&dir)? && !has_assembly_file(&dir)? {
+            let path = dir.join(EMPTY_S_NAME);
+            fs::write(&path, EMPTY_S)?;
+            written.push(path);
+        }
+    }
+    written.sort();
+    Ok(written)
+}
+
+/// Recursively collect `*.go` files under `dir`.
+fn go_files(dir: &Path, out: &mut Vec<PathBuf>) -> io::Result<()> {
+    for entry in fs::read_dir(dir)? {
+        let path = entry?.path();
+        if path.is_dir() {
+            go_files(&path, out)?;
+        } else if path.extension().is_some_and(|e| e == "go") {
+            out.push(path);
+        }
+    }
+    out.sort();
+    Ok(())
+}
+
+pub fn run(args: &[String]) -> io::Result<()> {
+    if args.is_empty() || args.iter().any(|a| a == "-h" || a == "--help") {
+        println!("{USAGE}");
+        return Ok(());
+    }
+
+    let mut total = 0usize;
+    let mut stubs = 0usize;
+    for dir in args {
+        for path in add_missing_assembly_stubs(Path::new(dir))? {
+            stubs += 1;
+            println!(
+                "  {}: added {EMPTY_S_NAME} (bodyless //go:wasmimport)",
+                path.display()
+            );
+        }
+
+        let mut files = Vec::new();
+        go_files(Path::new(dir), &mut files)?;
+        for path in files {
+            let src = fs::read_to_string(&path)?;
+            let (fixed, renamed) = fix_source(&src);
+            if renamed.is_empty() {
+                continue;
+            }
+            fs::write(&path, fixed)?;
+            total += renamed.len();
+            println!(
+                "  {}: renamed {} colliding tag const(s) -> *Tag ({})",
+                path.display(),
+                renamed.len(),
+                renamed.join(", ")
+            );
+        }
+    }
+    println!("go-bindgen-fixup: {total} constant(s) renamed, {stubs} assembly stub(s) added");
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicU64, Ordering};
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    /// Minimal std-only temp directory, removed on drop (so dev-tools stays dependency-free).
+    struct TmpDir(PathBuf);
+
+    impl TmpDir {
+        fn new() -> Self {
+            static COUNTER: AtomicU64 = AtomicU64::new(0);
+            let nanos = SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .unwrap()
+                .as_nanos();
+            let n = COUNTER.fetch_add(1, Ordering::Relaxed);
+            let path = std::env::temp_dir().join(format!(
+                "go-bindgen-fixup-test-{}-{nanos}-{n}",
+                std::process::id()
+            ));
+            fs::create_dir_all(&path).unwrap();
+            TmpDir(path)
+        }
+
+        fn path(&self) -> &Path {
+            &self.0
+        }
+    }
+
+    impl Drop for TmpDir {
+        fn drop(&mut self) {
+            let _ = fs::remove_dir_all(&self.0);
+        }
+    }
+
+    fn write_go(dir: &Path, name: &str, contents: &str) {
+        fs::create_dir_all(dir).unwrap();
+        fs::write(dir.join(name), contents).unwrap();
+    }
+
+    /// The real shape emitted for golem's `queued-card-event`, including the gofmt
+    /// alignment padding that makes the second constant easy to miss.
+    const SAMPLE: &str = "type QueuedCardEventInstall struct {\n\
+         \tCardId golem_core_types.CardId\n\
+         }\n\
+         \n\
+         type QueuedCardEventRevoke struct {\n\
+         \tCardId golem_core_types.CardId\n\
+         }\n\
+         \n\
+         const (\n\
+         \tQueuedCardEventInstall uint8 = 0\n\
+         \tQueuedCardEventRevoke  uint8 = 1\n\
+         )\n\
+         \n\
+         func (self QueuedCardEvent) Install() QueuedCardEventInstall {\n\
+         \tif self.tag != QueuedCardEventInstall {\n\
+         \t\tpanic(\"tag mismatch\")\n\
+         \t}\n\
+         \treturn self.value.(QueuedCardEventInstall)\n\
+         }\n\
+         \n\
+         func MakeQueuedCardEventInstall(value QueuedCardEventInstall) QueuedCardEvent {\n\
+         \treturn QueuedCardEvent{QueuedCardEventInstall, value}\n\
+         }\n\
+         \n\
+         \t\t\tcase QueuedCardEventInstall:\n";
+
+    #[test]
+    fn detects_both_collisions_including_gofmt_aligned_one() {
+        let (_, renamed) = fix_source(SAMPLE);
+        assert_eq!(
+            renamed,
+            vec!["QueuedCardEventInstall", "QueuedCardEventRevoke"]
+        );
+    }
+
+    #[test]
+    fn renames_the_constant_declarations_only() {
+        let (out, _) = fix_source(SAMPLE);
+        assert!(out.contains("\tQueuedCardEventInstallTag uint8 = 0"));
+        assert!(out.contains("\tQueuedCardEventRevokeTag uint8 = 1"));
+        // the record types keep their names
+        assert!(out.contains("type QueuedCardEventInstall struct {"));
+        assert!(out.contains("type QueuedCardEventRevoke struct {"));
+    }
+
+    #[test]
+    fn rewrites_constant_usages_but_not_type_usages() {
+        let (out, _) = fix_source(SAMPLE);
+        // constant positions
+        assert!(out.contains("if self.tag != QueuedCardEventInstallTag {"));
+        assert!(out.contains("QueuedCardEvent{QueuedCardEventInstallTag, value}"));
+        assert!(out.contains("case QueuedCardEventInstallTag:"));
+        // type positions must be untouched
+        assert!(out.contains("Install() QueuedCardEventInstall {"));
+        assert!(out.contains("self.value.(QueuedCardEventInstall)"));
+        assert!(out.contains("func MakeQueuedCardEventInstall(value QueuedCardEventInstall)"));
+    }
+
+    #[test]
+    fn is_idempotent() {
+        let (once, _) = fix_source(SAMPLE);
+        let (twice, renamed) = fix_source(&once);
+        assert_eq!(once, twice);
+        assert!(renamed.is_empty(), "second pass must find nothing to do");
+    }
+
+    #[test]
+    fn leaves_non_colliding_files_untouched() {
+        let src = "type Foo struct {\n\tA string\n}\n\nconst (\n\tBarInstall uint8 = 0\n)\n";
+        let (out, renamed) = fix_source(src);
+        assert_eq!(out, src);
+        assert!(renamed.is_empty());
+    }
+
+    #[test]
+    fn does_not_treat_arbitrary_constants_as_tags() {
+        // not a tag constant: wrong int type / not a plain integer literal
+        let src =
+            "type Foo struct {\n\tA string\n}\n\nconst (\n\tFoo int = 3\n\tBaz uint8 = x\n)\n";
+        let (_, renamed) = fix_source(src);
+        assert!(renamed.is_empty());
+    }
+
+    #[test]
+    fn adds_stub_to_a_package_with_bodyless_wasmimport() {
+        let tmp = TmpDir::new();
+        let pkg = tmp.path().join("wit_exports");
+        write_go(
+            &pkg,
+            "wit_exports.go",
+            "package wit_exports\n\n//go:wasmimport [export]x [task-return]save\nfunc f(a uintptr)\n",
+        );
+
+        let written = add_missing_assembly_stubs(tmp.path()).unwrap();
+        assert_eq!(written, vec![pkg.join("empty.s")]);
+        // byte-identical to what the generator writes for import packages
+        assert_eq!(fs::read_to_string(pkg.join("empty.s")).unwrap(), EMPTY_S);
+    }
+
+    #[test]
+    fn does_not_add_a_stub_when_one_already_exists() {
+        let tmp = TmpDir::new();
+        let pkg = tmp.path().join("imports");
+        write_go(
+            &pkg,
+            "b.go",
+            "package imports\n//go:wasmimport env f\nfunc f()\n",
+        );
+        fs::write(pkg.join("empty.s"), "// pre-existing").unwrap();
+
+        assert!(add_missing_assembly_stubs(tmp.path()).unwrap().is_empty());
+        assert_eq!(
+            fs::read_to_string(pkg.join("empty.s")).unwrap(),
+            "// pre-existing"
+        );
+    }
+
+    #[test]
+    fn does_not_add_a_stub_for_wasmexport_only_packages() {
+        // //go:wasmexport functions have bodies, so no assembly file is required.
+        let tmp = TmpDir::new();
+        let pkg = tmp.path().join("exports_only");
+        write_go(
+            &pkg,
+            "c.go",
+            "package x\n//go:wasmexport run\nfunc run() {}\n",
+        );
+
+        assert!(add_missing_assembly_stubs(tmp.path()).unwrap().is_empty());
+        assert!(!pkg.join("empty.s").exists());
+    }
+
+    #[test]
+    fn stub_addition_is_idempotent_and_recurses() {
+        let tmp = TmpDir::new();
+        let nested = tmp.path().join("a/b/deep_pkg");
+        write_go(
+            &nested,
+            "d.go",
+            "package deep\n//go:wasmimport env g\nfunc g()\n",
+        );
+
+        assert_eq!(add_missing_assembly_stubs(tmp.path()).unwrap().len(), 1);
+        assert!(add_missing_assembly_stubs(tmp.path()).unwrap().is_empty());
+    }
+
+    #[test]
+    fn preserves_trailing_newline() {
+        let (out, _) = fix_source(SAMPLE);
+        assert!(out.ends_with('\n'));
+    }
+}
diff --git a/dev-tools/go-bindgen-fixup/src/main.rs b/dev-tools/go-bindgen-fixup/src/main.rs
new file mode 100644
index 0000000000..60571b4253
--- /dev/null
+++ b/dev-tools/go-bindgen-fixup/src/main.rs
@@ -0,0 +1,26 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// Licensed under the Golem Source License v1.1 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://license.golem.cloud/LICENSE
+//
+// 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.
+
+use std::process::ExitCode;
+
+fn main() -> ExitCode {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    match go_bindgen_fixup::run(&args) {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(e) => {
+            eprintln!("go-bindgen-fixup: {e}");
+            ExitCode::FAILURE
+        }
+    }
+}
diff --git a/golem-skills/skills/common/golem-add-env-vars/SKILL.md b/golem-skills/skills/common/golem-add-env-vars/SKILL.md
index cc98be18d3..ec1c360b95 100644
--- a/golem-skills/skills/common/golem-add-env-vars/SKILL.md
+++ b/golem-skills/skills/common/golem-add-env-vars/SKILL.md
@@ -185,7 +185,13 @@ The same `{{ VAR }}` syntax also works in:
 
 ## Reading Environment Variables in Agent Code
 
-**Rust and TypeScript** agents use the standard APIs to read environment variables (`std::env::var` in Rust, `process.env` in TypeScript).
+**Rust, TypeScript, and Go** agents use the standard APIs to read environment variables (`std::env::var` in Rust, `process.env` in TypeScript, `os.Getenv` / `os.Environ` in Go). Go needs no special wiring — the std-library `os` package works inside the WASM runtime because `componentize-go`'s `wasi_snapshot_preview1` adapter maps Go's environ calls onto `wasi:cli/environment`. Example:
+
+```go
+import "os"
+
+appMode := os.Getenv("APP_MODE") // "" if unset
+```
 
 **Scala** agents must use `golem.wasi.Environment.getEnvironment()` which returns a `Map[String, String]` of all environment variables via the WASI `wasi:cli/environment@0.2.3` interface. Standard Scala `sys.env` does **not** work inside the WASM runtime. Example:
 
diff --git a/sdks/go/golem/.gitignore b/sdks/go/golem/.gitignore
new file mode 100644
index 0000000000..e25e5e2af2
--- /dev/null
+++ b/sdks/go/golem/.gitignore
@@ -0,0 +1,9 @@
+# Built components. Regenerated by `componentize-go build`; no SDK ships a
+# committed .wasm (unlike the TS/Scala QuickJS base images, Go compiles the
+# guest from source, so there is no prebuilt artifact to check in).
+*.wasm
+
+# golem-cli local state, if an example is run through the CLI
+.golem/
+.golem-local/
+golem-temp/
diff --git a/sdks/go/golem/.golangci.yml b/sdks/go/golem/.golangci.yml
new file mode 100644
index 0000000000..8afae7596a
--- /dev/null
+++ b/sdks/go/golem/.golangci.yml
@@ -0,0 +1,26 @@
+version: "2"
+
+# Lints the hand-written SDK package. The generated bindings under internal/wit
+# and internal/exports are excluded (wit-bindgen's "// Generated by ... DO NOT
+# EDIT!" header is not the standard "// Code generated ... DO NOT EDIT." marker,
+# so they must be excluded explicitly).
+linters:
+  default: standard # errcheck, govet, ineffassign, staticcheck, unused
+  settings:
+    staticcheck:
+      # golangci-lint disables the doc-comment-form checks (ST1020-1022) by
+      # default; keep them on so a declaration comment that doesn't start with
+      # the identifier fails lint. The remaining opt-outs are style checks we do
+      # not want to enforce here (package comments, initialism naming like
+      # Id->ID, receiver-name consistency, gopls quick-fix hints).
+      checks:
+        - all
+        - -ST1000
+        - -ST1003
+        - -ST1016
+        - -QF1008
+  exclusions:
+    generated: strict
+    paths:
+      - internal/wit
+      - internal/exports
diff --git a/sdks/go/golem/LICENSE b/sdks/go/golem/LICENSE
new file mode 100644
index 0000000000..261eeb9e9f
--- /dev/null
+++ b/sdks/go/golem/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/sdks/go/golem/agentid.go b/sdks/go/golem/agentid.go
new file mode 100644
index 0000000000..49ecf8db65
--- /dev/null
+++ b/sdks/go/golem/agentid.go
@@ -0,0 +1,96 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"encoding/binary"
+	"fmt"
+	"reflect"
+
+	host "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_host"
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	"github.com/golemcloud/golem/sdks/go/golem/uuid"
+)
+
+// UUID is a 128-bit identifier, used here for the phantom id of an ephemeral
+// agent instance. It aliases [uuid.UUID] so capability wrappers can use the type
+// without importing the agent runtime.
+type UUID = uuid.UUID
+
+func uuidFromWit(w types.Uuid) UUID {
+	var u UUID
+	binary.BigEndian.PutUint64(u[0:8], w.HighBits)
+	binary.BigEndian.PutUint64(u[8:16], w.LowBits)
+	return u
+}
+
+func uuidToWit(u UUID) types.Uuid {
+	return types.Uuid{
+		HighBits: binary.BigEndian.Uint64(u[0:8]),
+		LowBits:  binary.BigEndian.Uint64(u[8:16]),
+	}
+}
+
+// ParsedAgentID is the typed decomposition of an agent id string: the agent
+// type name, the constructor parameters decoded back into the Id type, and the
+// phantom id (present for phantom/ephemeral instances).
+type ParsedAgentID[Id any] struct {
+	TypeName  string
+	ID        Id
+	PhantomID Option[UUID]
+}
+
+// ParseAgentID decodes an agent id string (e.g. from [Context.AgentID] or a
+// method parameter carrying another agent's id) into its typed form.
+//
+// Id must be the target agent's Id struct — the same type used with
+// [DefineAgent]/[ClientFor] — so the constructor parameters decode back into it.
+// This calls the host `parse-agent-id`, so it runs only inside a component, not
+// in native tests; the decode itself ([decodeAgentIDParams]) is separately
+// testable.
+func ParseAgentID[Id any](agentID string) (ParsedAgentID[Id], error) {
+	res := host.ParseAgentId(agentID)
+	if res.IsErr() {
+		return ParsedAgentID[Id]{}, fmt.Errorf("golem: parsing agent id %q: %w", agentID, agentErrorToGo(res.Err()))
+	}
+	t := res.Ok()
+
+	id, err := decodeAgentIDParams[Id](t.F1.Value)
+	if err != nil {
+		return ParsedAgentID[Id]{}, fmt.Errorf("golem: agent id %q: %w", agentID, err)
+	}
+
+	phantom := None[UUID]()
+	if t.F2.IsSome() {
+		phantom = Some(uuidFromWit(t.F2.Some()))
+	}
+	return ParsedAgentID[Id]{TypeName: t.F0, ID: id, PhantomID: phantom}, nil
+}
+
+// decodeAgentIDParams decodes a constructor-parameter value tree into the Id
+// struct — the same positional record decode initialize uses for the raw
+// constructor input. Pure (no host import), so it is natively testable.
+func decodeAgentIDParams[Id any](value types.SchemaValueTree) (Id, error) {
+	var zero Id
+	idType := reflect.TypeFor[Id]()
+	if idType.Kind() != reflect.Struct {
+		return zero, fmt.Errorf("id type %s must be a struct", idType)
+	}
+	idVal := reflect.New(idType).Elem()
+	if err := decodeParams(value, defs.structFields(idType), idVal); err != nil {
+		return zero, err
+	}
+	return idVal.Interface().(Id), nil
+}
diff --git a/sdks/go/golem/agentid_test.go b/sdks/go/golem/agentid_test.go
new file mode 100644
index 0000000000..0ce39a47da
--- /dev/null
+++ b/sdks/go/golem/agentid_test.go
@@ -0,0 +1,45 @@
+package golem
+
+import (
+	"reflect"
+	"testing"
+
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+)
+
+// parsedID — The host `parse-agent-id` call can't link natively, but the decode of its
+// constructor-param value tree into the typed Id can — and is where a bug would
+// hide. Round-trip: encode an Id's fields, then decode via decodeAgentIDParams.
+type parsedID struct {
+	Merchant string
+	Region   int32
+}
+
+func TestDecodeAgentIDParamsRoundTrip(t *testing.T) {
+	want := parsedID{Merchant: "acme", Region: 7}
+	fields := defs.structFields(reflect.TypeFor[parsedID]())
+	tree := encodeParams(fields, reflect.ValueOf(&want).Elem())
+
+	got, err := decodeAgentIDParams[parsedID](tree)
+	if err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if got != want {
+		t.Fatalf("round trip = %#v, want %#v", got, want)
+	}
+}
+
+func TestDecodeAgentIDParamsRejectsNonStruct(t *testing.T) {
+	if _, err := decodeAgentIDParams[string](types.SchemaValueTree{}); err == nil {
+		t.Fatal("a non-struct Id should be rejected")
+	}
+}
+
+func TestUUIDFromWitAndString(t *testing.T) {
+	// HighBits/LowBits laid out big-endian across the 16 bytes.
+	u := uuidFromWit(types.Uuid{HighBits: 0x0011223344556677, LowBits: 0x8899aabbccddeeff})
+	want := "00112233-4455-6677-8899-aabbccddeeff"
+	if u.String() != want {
+		t.Fatalf("uuid = %s, want %s", u.String(), want)
+	}
+}
diff --git a/sdks/go/golem/blobstore/blobstore.go b/sdks/go/golem/blobstore/blobstore.go
new file mode 100644
index 0000000000..ee6de2397c
--- /dev/null
+++ b/sdks/go/golem/blobstore/blobstore.go
@@ -0,0 +1,353 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 blobstore is a Go wrapper over Golem's durable object store
+// (wasi:blobstore). Create or open a [Container], then read and write named blobs.
+//
+// Like [keyvalue], these are I/O operations that return an error (a missing
+// object is reported as found=false, not an error), distinct from the fail-loud
+// exactly-once control-flow surface. The store is durable, and because operations
+// are remote side effects, calling them inside a read-only method traps.
+//
+// Pair a fallible call with golem.Must / golem.Must0 / golem.Must2 to abort the
+// invocation on error.
+package blobstore
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	bstore "github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_blobstore_blobstore"
+	bscontainer "github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_blobstore_container"
+	bstypes "github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_blobstore_types"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// Error is a blobstore host error (the host reports errors as plain strings).
+type Error struct{ Message string }
+
+func (e *Error) Error() string { return "golem/blobstore: " + e.Message }
+
+func bsError(msg string) error { return &Error{Message: msg} }
+
+// ObjectID identifies an object by its container and name (for [CopyObject] /
+// [MoveObject]).
+type ObjectID struct {
+	Container string
+	Object    string
+}
+
+func (o ObjectID) toWit() bstypes.ObjectId {
+	return bstypes.ObjectId{Container: o.Container, Object: o.Object}
+}
+
+// ContainerMetadata describes a container.
+type ContainerMetadata struct {
+	Name string
+	// CreatedAt is the container's creation time (host millis). Some backends
+	// report last-modified here rather than creation.
+	CreatedAt time.Time
+}
+
+// ObjectMetadata describes an object.
+type ObjectMetadata struct {
+	Name      string
+	Container string
+	// CreatedAt is the object's creation time (host millis; see [ContainerMetadata]).
+	CreatedAt time.Time
+	Size      uint64
+}
+
+// ── Top-level container operations ────────────────────────────────────────────
+
+// CreateContainer creates a new container.
+func CreateContainer(name string) (*Container, error) {
+	r := bstore.CreateContainer(name)
+	if r.IsErr() {
+		return nil, bsError(r.Err())
+	}
+	return &Container{raw: r.Ok(), name: name}, nil
+}
+
+// GetContainer opens an existing container.
+func GetContainer(name string) (*Container, error) {
+	r := bstore.GetContainer(name)
+	if r.IsErr() {
+		return nil, bsError(r.Err())
+	}
+	return &Container{raw: r.Ok(), name: name}, nil
+}
+
+// GetOrCreateContainer returns the container, creating it if it does not exist.
+// It tolerates a concurrent create (the create/get race).
+func GetOrCreateContainer(name string) (*Container, error) {
+	exists, err := ContainerExists(name)
+	if err != nil {
+		return nil, err
+	}
+	if exists {
+		return GetContainer(name)
+	}
+	c, err := CreateContainer(name)
+	if err != nil {
+		// Possibly created concurrently between the check and the create.
+		if got, gerr := GetContainer(name); gerr == nil {
+			return got, nil
+		}
+		return nil, err
+	}
+	return c, nil
+}
+
+// ContainerExists reports whether a container exists.
+func ContainerExists(name string) (bool, error) {
+	r := bstore.ContainerExists(name)
+	if r.IsErr() {
+		return false, bsError(r.Err())
+	}
+	return r.Ok(), nil
+}
+
+// DeleteContainer deletes a container and its objects.
+func DeleteContainer(name string) error {
+	if r := bstore.DeleteContainer(name); r.IsErr() {
+		return bsError(r.Err())
+	}
+	return nil
+}
+
+// CopyObject copies an object from src to dest (across containers if they differ).
+func CopyObject(src, dest ObjectID) error {
+	if r := bstore.CopyObject(src.toWit(), dest.toWit()); r.IsErr() {
+		return bsError(r.Err())
+	}
+	return nil
+}
+
+// MoveObject moves an object from src to dest.
+func MoveObject(src, dest ObjectID) error {
+	if r := bstore.MoveObject(src.toWit(), dest.toWit()); r.IsErr() {
+		return bsError(r.Err())
+	}
+	return nil
+}
+
+// ── Container ─────────────────────────────────────────────────────────────────
+
+// Container is a handle to an open blob container.
+type Container struct {
+	raw  *bscontainer.Container
+	name string
+}
+
+// Name returns the container's name.
+func (c *Container) Name() string { return c.name }
+
+// Info returns the container's metadata.
+func (c *Container) Info() (ContainerMetadata, error) {
+	r := c.raw.Info()
+	if r.IsErr() {
+		return ContainerMetadata{}, bsError(r.Err())
+	}
+	m := r.Ok()
+	return ContainerMetadata{Name: m.Name, CreatedAt: millis(m.CreatedAt)}, nil
+}
+
+// Has reports whether the named object exists.
+func (c *Container) Has(name string) (bool, error) {
+	r := c.raw.HasObject(name)
+	if r.IsErr() {
+		return false, bsError(r.Err())
+	}
+	return r.Ok(), nil
+}
+
+// ObjectInfo returns metadata for the named object (an error if it is absent).
+func (c *Container) ObjectInfo(name string) (ObjectMetadata, error) {
+	r := c.raw.ObjectInfo(name)
+	if r.IsErr() {
+		return ObjectMetadata{}, bsError(r.Err())
+	}
+	m := r.Ok()
+	return ObjectMetadata{Name: m.Name, Container: m.Container, CreatedAt: millis(m.CreatedAt), Size: m.Size}, nil
+}
+
+// Delete removes the named object (a no-op if it is absent).
+func (c *Container) Delete(name string) error {
+	if r := c.raw.DeleteObject(name); r.IsErr() {
+		return bsError(r.Err())
+	}
+	return nil
+}
+
+// DeleteMany removes several objects at once.
+func (c *Container) DeleteMany(names []string) error {
+	if r := c.raw.DeleteObjects(names); r.IsErr() {
+		return bsError(r.Err())
+	}
+	return nil
+}
+
+// Clear removes all objects, leaving the container empty.
+func (c *Container) Clear() error {
+	if r := c.raw.Clear(); r.IsErr() {
+		return bsError(r.Err())
+	}
+	return nil
+}
+
+// ListObjects returns all object names in the container. Order is not guaranteed.
+func (c *Container) ListObjects() ([]string, error) {
+	r := c.raw.ListObjects()
+	if r.IsErr() {
+		return nil, bsError(r.Err())
+	}
+	return drainStrings(r.Ok()), nil
+}
+
+// GetData reads the whole object's bytes. found is false (nil error) when the
+// object is absent.
+func (c *Container) GetData(name string) (data []byte, found bool, err error) {
+	has, err := c.Has(name)
+	if err != nil || !has {
+		return nil, false, err
+	}
+	info, err := c.ObjectInfo(name)
+	if err != nil {
+		return nil, false, err
+	}
+	if info.Size == 0 {
+		return []byte{}, true, nil
+	}
+	// The WIT spec says the range end is inclusive, but Golem's in-memory/fs
+	// backends treat it as exclusive. Try inclusive first, then recover.
+	first, err := c.getRange(name, 0, info.Size-1)
+	if err != nil {
+		return nil, false, err
+	}
+	if uint64(len(first)) == info.Size {
+		return first, true, nil
+	}
+	rest, err := c.getRange(name, 0, info.Size)
+	if err != nil {
+		return nil, false, err
+	}
+	return rest, true, nil
+}
+
+// GetRange reads bytes [start, end] of an object. The host's inclusive/exclusive
+// treatment of end differs across backends, so ranged reads are not portable —
+// prefer [Container.GetData] for whole objects.
+func (c *Container) GetRange(name string, start, end uint64) ([]byte, error) {
+	return c.getRange(name, start, end)
+}
+
+func (c *Container) getRange(name string, start, end uint64) ([]byte, error) {
+	r := c.raw.GetData(name, start, end)
+	if r.IsErr() {
+		return nil, bsError(r.Err())
+	}
+	cr := r.Ok().IncomingValueConsumeSync()
+	if cr.IsErr() {
+		return nil, bsError(cr.Err())
+	}
+	return cr.Ok(), nil
+}
+
+// WriteData creates or replaces the named object with data.
+func (c *Container) WriteData(name string, data []byte) error {
+	ov := bstypes.OutgoingValueNewOutgoingValue()
+	writer, reader := bstypes.MakeStreamU8()
+	if r := ov.OutgoingValueWriteBody(reader); r.IsErr() {
+		return bsError("outgoing-value write-body failed")
+	}
+	// Feed the bytes into the stream and close it, then hand the outgoing value
+	// to write-data (which reads the buffered stream).
+	writer.WriteAll(data)
+	writer.Drop()
+	if r := c.raw.WriteData(name, ov); r.IsErr() {
+		return bsError(r.Err())
+	}
+	return nil
+}
+
+func drainStrings(r *witTypes.StreamReader[string]) []string {
+	var out []string
+	buf := make([]string, 256)
+	for {
+		n := r.Read(buf)
+		if n > 0 {
+			out = append(out, buf[:n]...)
+		}
+		if r.WriterDropped() && n == 0 {
+			break
+		}
+	}
+	r.Drop()
+	return out
+}
+
+func millis(ms uint64) time.Time { return time.UnixMilli(int64(ms)) }
+
+// ── Typed store ───────────────────────────────────────────────────────────────
+
+// Store is a typed view over a [Container]: object bodies are JSON-encoded T.
+// Build one with [Typed].
+type Store[T any] struct{ c *Container }
+
+// Typed wraps a container as a JSON-encoded store of T.
+func Typed[T any](c *Container) *Store[T] { return &Store[T]{c: c} }
+
+// Get decodes the named object as T. found is false (nil error) when absent.
+func (s *Store[T]) Get(name string) (value T, found bool, err error) {
+	raw, found, err := s.c.GetData(name)
+	if err != nil || !found {
+		var zero T
+		return zero, found, err
+	}
+	v, err := unmarshalValue[T](raw)
+	if err != nil {
+		var zero T
+		return zero, true, fmt.Errorf("golem/blobstore: decoding %q: %w", name, err)
+	}
+	return v, true, nil
+}
+
+// Set JSON-encodes value and writes it as the named object.
+func (s *Store[T]) Set(name string, value T) error {
+	raw, err := marshalValue(value)
+	if err != nil {
+		return fmt.Errorf("golem/blobstore: encoding %q: %w", name, err)
+	}
+	return s.c.WriteData(name, raw)
+}
+
+// Delete removes the named object.
+func (s *Store[T]) Delete(name string) error { return s.c.Delete(name) }
+
+// Exists reports whether the named object is present.
+func (s *Store[T]) Exists(name string) (bool, error) { return s.c.Has(name) }
+
+// List returns the object names.
+func (s *Store[T]) List() ([]string, error) { return s.c.ListObjects() }
+
+// marshalValue/unmarshalValue are the pure JSON codec behind Store (no host
+// calls), so they are natively testable.
+func marshalValue[T any](v T) ([]byte, error) { return json.Marshal(v) }
+func unmarshalValue[T any](data []byte) (T, error) {
+	var v T
+	err := json.Unmarshal(data, &v)
+	return v, err
+}
diff --git a/sdks/go/golem/blobstore/blobstore_test.go b/sdks/go/golem/blobstore/blobstore_test.go
new file mode 100644
index 0000000000..d8a6776742
--- /dev/null
+++ b/sdks/go/golem/blobstore/blobstore_test.go
@@ -0,0 +1,54 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 blobstore
+
+import (
+	"testing"
+	"time"
+)
+
+// TestTypedCodecRoundTrip — the pure JSON codec behind Store round-trips a value.
+func TestTypedCodecRoundTrip(t *testing.T) {
+	type Doc struct {
+		Title string
+		Tags  []string
+	}
+	want := Doc{Title: "spec", Tags: []string{"a", "b"}}
+	raw, err := marshalValue(want)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+	got, err := unmarshalValue[Doc](raw)
+	if err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	if got.Title != want.Title || len(got.Tags) != 2 {
+		t.Fatalf("round-trip = %+v", got)
+	}
+}
+
+// TestMillis — host millis map to time.Time.
+func TestMillis(t *testing.T) {
+	if got := millis(1500); !got.Equal(time.UnixMilli(1500)) {
+		t.Fatalf("millis(1500) = %v", got)
+	}
+}
+
+// TestErrorFormatting — the bare-string host error renders with the package prefix.
+func TestErrorFormatting(t *testing.T) {
+	if e := bsError("no such container"); e.Error() != "golem/blobstore: no such container" {
+		t.Fatalf("Error() = %q", e.Error())
+	}
+}
diff --git a/sdks/go/golem/client.go b/sdks/go/golem/client.go
new file mode 100644
index 0000000000..056960b585
--- /dev/null
+++ b/sdks/go/golem/client.go
@@ -0,0 +1,196 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"fmt"
+	"reflect"
+
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+	host "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_host"
+	apiHost "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_host"
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// Client addresses one agent instance for remote calls. It is produced by
+// [ClientFor] and consumed by the call methods on [MethodDef].
+//
+// The Id type parameter is what makes cross-agent calls type-safe: a
+// MethodDef[PaymentId, …] only accepts a Client[PaymentId], so aiming a method
+// at the wrong agent is a compile error rather than a runtime not-found.
+//
+// Client carries no type parameter for state: the caller does not know, and
+// must not depend on, how the target stores anything.
+type Client[Id any] struct {
+	rpc       *host.WasmRpc
+	agentType string
+	agentID   string
+	phantomID Option[UUID]
+}
+
+// AgentID returns the target's agent id, as resolved by the host.
+func (c Client[Id]) AgentID() string { return c.agentID }
+
+// PhantomID returns the phantom instance id this client addresses, or None for a
+// durable client. A [NewPhantom] client carries the freshly allocated id here
+// (re-address it later with [WithPhantomID]).
+func (c Client[Id]) PhantomID() Option[UUID] { return c.phantomID }
+
+// ClientOpt configures a client.
+type ClientOpt func(*clientOpts)
+
+type clientOpts struct {
+	phantomID witTypes.Option[types.Uuid]
+	configs   []configOverrideFn
+}
+
+// WithPhantomID addresses a specific phantom instance of the target agent.
+// Use [NewPhantom] to allocate a fresh one.
+func WithPhantomID(id UUID) ClientOpt {
+	return func(o *clientOpts) { o.phantomID = witTypes.Some(uuidToWit(id)) }
+}
+
+// ClientFor returns a client addressing the agent instance identified by id, or
+// panics if the target can't be resolved (unknown agent, a bad config override,
+// or invalid constructor parameters). Client creation failing is a programming/
+// configuration error with no in-band recovery, so — like the TS/Rust/Scala SDKs
+// — it fails loud: the panic is recovered by the invoke dispatcher into an
+// agent-error.
+//
+// The id is encoded with the same codecs the target uses to decode its
+// constructor parameters — they are derived from the same Go types — so caller
+// and callee agree by construction rather than by convention.
+func ClientFor[Id any, S any, Cfg any](a *Agent[Id, S, Cfg], id Id, opts ...ClientOpt) Client[Id] {
+	e := defs.agents[a.name]
+	if e == nil {
+		panic(fmt.Errorf("golem: ClientFor: unknown agent %s", a.name))
+	}
+
+	var o clientOpts
+	o.phantomID = witTypes.None[types.Uuid]()
+	for _, f := range opts {
+		f(&o)
+	}
+
+	idVal := reflect.ValueOf(&id).Elem()
+	ctor := encodeParams(e.idFields, idVal)
+
+	// Encode and validate any config overrides against the target's declarations
+	// before touching the host, so a mistyped or undeclared key is a clear error.
+	agentConfig, err := buildAgentConfig(defs, e, o.configs)
+	if err != nil {
+		panic(fmt.Errorf("golem: ClientFor %s: %w", a.name, err))
+	}
+
+	// Resolve the id up front: it is wanted for error messages, and a failure
+	// here means the constructor parameters are wrong — better to surface that
+	// now than as an opaque not-found on the first call.
+	resolved := host.MakeAgentId(a.name, ctor, o.phantomID)
+	if resolved.IsErr() {
+		panic(fmt.Errorf("golem: ClientFor %s: %w", a.name, agentErrorToGo(resolved.Err())))
+	}
+
+	phantomID := None[UUID]()
+	if o.phantomID.IsSome() {
+		phantomID = Some(uuidFromWit(o.phantomID.Some()))
+	}
+	return Client[Id]{
+		rpc:       host.MakeWasmRpc(a.name, ctor, o.phantomID, agentConfig),
+		agentType: a.name,
+		agentID:   resolved.Ok(),
+		phantomID: phantomID,
+	}
+}
+
+// NewPhantom allocates a fresh phantom instance of the target agent and returns
+// a client for it (panicking on failure, like [ClientFor]). The freshly allocated
+// phantom id rides on the client — read it back with [Client.PhantomID] to
+// address the same instance again (via [WithPhantomID]).
+//
+// Ephemeral agents have no durable identity, so this is the only way to obtain
+// a client for one.
+func NewPhantom[Id any, S any, Cfg any](a *Agent[Id, S, Cfg], id Id) Client[Id] {
+	phantom := uuidFromWit(apiHost.GenerateIdempotencyKey())
+	return ClientFor(a, id, WithPhantomID(phantom))
+}
+
+// AgentErrorKind classifies an [AgentError].
+type AgentErrorKind uint8
+
+const (
+	// AgentInvalidInput — the input did not match the method's parameters.
+	AgentInvalidInput AgentErrorKind = iota
+	// AgentInvalidMethod — no such method on the agent.
+	AgentInvalidMethod
+	// AgentInvalidType — no such agent type.
+	AgentInvalidType
+	// AgentCustom — the agent failed (a returned error or a panic).
+	AgentCustom
+	// AgentUnknown — an error kind the SDK does not recognize.
+	AgentUnknown
+)
+
+// AgentError is a typed error from invoking an agent. Its Kind lets callers
+// classify the failure with errors.As, rather than string-matching the message.
+type AgentError struct {
+	Kind    AgentErrorKind
+	Message string
+}
+
+func (e *AgentError) Error() string {
+	switch e.Kind {
+	case AgentInvalidInput:
+		return "invalid input: " + e.Message
+	case AgentInvalidMethod:
+		return "invalid method: " + e.Message
+	case AgentInvalidType:
+		return "invalid type: " + e.Message
+	case AgentCustom:
+		return "custom error: " + e.Message
+	default:
+		return e.Message
+	}
+}
+
+// agentErrorToGo converts a host agent-error into a typed [AgentError], keeping
+// the case inspectable rather than flattening everything to a string.
+func agentErrorToGo(e common.AgentError) error {
+	switch e.Tag() {
+	case common.AgentErrorInvalidInput:
+		return &AgentError{Kind: AgentInvalidInput, Message: e.InvalidInput()}
+	case common.AgentErrorInvalidMethod:
+		return &AgentError{Kind: AgentInvalidMethod, Message: e.InvalidMethod()}
+	case common.AgentErrorInvalidType:
+		return &AgentError{Kind: AgentInvalidType, Message: e.InvalidType()}
+	case common.AgentErrorCustomError:
+		return &AgentError{Kind: AgentCustom, Message: customErrorMessage(e.CustomError())}
+	default:
+		return &AgentError{Kind: AgentUnknown, Message: fmt.Sprintf("agent error (tag %d)", e.Tag())}
+	}
+}
+
+// customErrorMessage recovers the string payload the SDK encodes into the
+// custom-error case (see customError). Without this the TypedSchemaValue would
+// render as a struct dump, and — on the RPC path — a remote agent's panic message
+// would reach the caller as that dump. Non-string payloads fall back to %v.
+func customErrorMessage(tsv types.TypedSchemaValue) string {
+	nodes := tsv.Value.ValueNodes
+	root := int(tsv.Value.Root)
+	if root >= 0 && root < len(nodes) && nodes[root].Tag() == types.SchemaValueNodeStringValue {
+		return nodes[root].StringValue()
+	}
+	return fmt.Sprintf("%v", tsv)
+}
diff --git a/sdks/go/golem/client_test.go b/sdks/go/golem/client_test.go
new file mode 100644
index 0000000000..d756a679b9
--- /dev/null
+++ b/sdks/go/golem/client_test.go
@@ -0,0 +1,63 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"errors"
+	"testing"
+
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+)
+
+// TestAgentErrorToGoDistinguishesCases — agentErrorToGo maps each host agent-error case onto a distinguishable Go error
+// rather than flattening them into one string. Pure, so it is covered natively;
+// ClientFor, which calls it around a host import, is covered by integration.
+func TestAgentErrorToGoDistinguishesCases(t *testing.T) {
+	cases := []struct {
+		name string
+		in   common.AgentError
+		want string
+	}{
+		{"invalid input", common.MakeAgentErrorInvalidInput("bad field"), "invalid input: bad field"},
+		{"invalid method", common.MakeAgentErrorInvalidMethod("no such method"), "invalid method: no such method"},
+		{"invalid type", common.MakeAgentErrorInvalidType("no such type"), "invalid type: no such type"},
+	}
+	for _, tc := range cases {
+		if got := agentErrorToGo(tc.in).Error(); got != tc.want {
+			t.Errorf("%s: agentErrorToGo = %q, want %q", tc.name, got, tc.want)
+		}
+	}
+
+	// The custom-error case carries a string payload; it must round-trip intact
+	// (not render as a struct dump — see customErrorMessage).
+	if got := agentErrorToGo(customError("boom")).Error(); got != "custom error: boom" {
+		t.Errorf("custom error mapped to %q, want %q", got, "custom error: boom")
+	}
+}
+
+// TestAgentErrorIsRecoverable — the kind is inspectable via errors.As.
+func TestAgentErrorIsRecoverable(t *testing.T) {
+	err := agentErrorToGo(customError("boom"))
+	var ae *AgentError
+	if !errors.As(err, &ae) {
+		t.Fatalf("agentErrorToGo did not return an *AgentError: %T", err)
+	}
+	if ae.Kind != AgentCustom || ae.Message != "boom" {
+		t.Fatalf("AgentError = {Kind:%d Message:%q}, want {Custom, boom}", ae.Kind, ae.Message)
+	}
+	if got := agentErrorToGo(common.MakeAgentErrorInvalidMethod("nope")); got.(*AgentError).Kind != AgentInvalidMethod {
+		t.Fatalf("invalid-method kind = %d", got.(*AgentError).Kind)
+	}
+}
diff --git a/sdks/go/golem/codec.go b/sdks/go/golem/codec.go
new file mode 100644
index 0000000000..4fdea9d1da
--- /dev/null
+++ b/sdks/go/golem/codec.go
@@ -0,0 +1,324 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// codec is everything the SDK knows about one Go type: how to describe it in
+// the schema graph, how to encode a value of it, and how to decode one.
+//
+// Bundling the three together is deliberate. The schema and the value tree must
+// agree structurally — a record type with three fields must be matched by a
+// record value with three children, in the same order — and nothing on the wire
+// enforces that. Deriving all three from one place makes disagreement
+// impossible by construction, instead of a convention three separate walks have
+// to keep by hand.
+//
+// Nesting is composition: the codec for Option[Result[T, E]] is built from the
+// codec for Result[T, E], which is built from the codecs for T and E. No
+// composite needs to know how deep it sits.
+type codec struct {
+	typ  reflect.Type
+	body func(*graphBuilder) types.SchemaTypeBody
+
+	// recursive marks a type reachable from itself. WIT cannot express a raw
+	// cycle in the flat node list — a consumer decoding one rejects it with
+	// CyclicTypeWithoutRef — so such a type is emitted as a named def and
+	// referenced through ref-type, which is the only valid recursion form.
+	recursive bool
+	// building is true while this codec's children are being compiled. Re-entry
+	// while building is exactly what identifies a recursive type.
+	building bool
+	// invalid is non-empty when the type cannot be represented (unsupported
+	// kind, platform-dependent width, unregistered variant, …). Set by
+	// markInvalid instead of panicking; the schema builder collects these per
+	// agent so the problem is attributed and reported at discovery.
+	invalid string
+
+	encode func(*valBuilder, reflect.Value) int32
+	decode func(*decoder, reflect.Value, int32) error
+}
+
+// compile returns the codec for t, building it if this is the first request.
+// Results are memoized in defs.codecs (compilation runs single-goroutine at
+// registration, so no locking is needed).
+//
+// The cache entry is installed *before* the children are compiled, so a
+// self-referential type resolves to the in-progress codec rather than recursing
+// forever. Its function fields are still nil at that moment, but every use is
+// behind a closure that dereferences them at call time, by which point the
+// outer compile has filled them in.
+func (d *definitions) compile(t reflect.Type) *codec {
+	if c, ok := d.codecs[t]; ok {
+		if c.building {
+			// Reached t again while still compiling it: t is reachable from
+			// itself. Marking one member of each cycle is enough — its ref-type
+			// node breaks the cycle for every path through it.
+			c.recursive = true
+		}
+		return c
+	}
+	c := &codec{typ: t, building: true}
+	d.codecs[t] = c
+	d.buildCodec(c)
+	c.building = false
+	return c
+}
+
+// typeID derives the stable, language-independent identifier a named def
+// carries. A pinned id (via [NameType]) wins, so cross-language consumers can be
+// made to agree; otherwise it is derived from the Go type's package path + name.
+func (d *definitions) typeID(t reflect.Type) string {
+	if id, ok := d.pins[t]; ok {
+		return id
+	}
+	name := t.Name()
+	if name == "" {
+		return ""
+	}
+	if pkg := t.PkgPath(); pkg != "" {
+		return strings.ReplaceAll(pkg, "/", ".") + "." + name
+	}
+	return name
+}
+
+func (d *definitions) buildCodec(c *codec) {
+	// User-declared variants and enums are looked up before the kind switch:
+	// an enum is a named integer, which would otherwise compile as a plain
+	// integer, and a variant is an interface, which has no other meaning.
+	if vd, ok := d.variants[c.typ]; ok {
+		d.compileVariant(c, vd)
+		return
+	}
+	if ed, ok := d.enums[c.typ]; ok {
+		compileEnum(c, ed)
+		return
+	}
+	// SDK composite types are structs, so they must be recognised before the
+	// generic struct-as-record case. The check is an interface assertion on the
+	// zero value, done once here rather than per value.
+	if d.sdkComposite(c) {
+		return
+	}
+
+	// Concrete named types are matched exactly, before the kind switch would
+	// treat them as their underlying primitive.
+	if fill, ok := namedTypeCodecs[c.typ]; ok {
+		fill(c)
+		return
+	}
+
+	none := witTypes.None[types.NumericRestrictions]()
+
+	switch c.typ.Kind() {
+	case reflect.String:
+		scalar(c, types.MakeSchemaTypeBodyStringType(), types.SchemaValueNodeStringValue,
+			func(b *valBuilder, v reflect.Value) int32 {
+				return b.push(types.MakeSchemaValueNodeStringValue(v.String()))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) { dst.SetString(n.StringValue()) })
+
+	case reflect.Bool:
+		scalar(c, types.MakeSchemaTypeBodyBoolType(), types.SchemaValueNodeBoolValue,
+			func(b *valBuilder, v reflect.Value) int32 {
+				return b.push(types.MakeSchemaValueNodeBoolValue(v.Bool()))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) { dst.SetBool(n.BoolValue()) })
+
+	case reflect.Int64:
+		scalar(c, types.MakeSchemaTypeBodyS64Type(none), types.SchemaValueNodeS64Value,
+			func(b *valBuilder, v reflect.Value) int32 {
+				return b.push(types.MakeSchemaValueNodeS64Value(v.Int()))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) { dst.SetInt(n.S64Value()) })
+
+	case reflect.Int32:
+		scalar(c, types.MakeSchemaTypeBodyS32Type(none), types.SchemaValueNodeS32Value,
+			func(b *valBuilder, v reflect.Value) int32 {
+				return b.push(types.MakeSchemaValueNodeS32Value(int32(v.Int())))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) { dst.SetInt(int64(n.S32Value())) })
+
+	case reflect.Int16:
+		scalar(c, types.MakeSchemaTypeBodyS16Type(none), types.SchemaValueNodeS16Value,
+			func(b *valBuilder, v reflect.Value) int32 {
+				return b.push(types.MakeSchemaValueNodeS16Value(int16(v.Int())))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) { dst.SetInt(int64(n.S16Value())) })
+
+	case reflect.Int8:
+		scalar(c, types.MakeSchemaTypeBodyS8Type(none), types.SchemaValueNodeS8Value,
+			func(b *valBuilder, v reflect.Value) int32 {
+				return b.push(types.MakeSchemaValueNodeS8Value(int8(v.Int())))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) { dst.SetInt(int64(n.S8Value())) })
+
+	case reflect.Uint64:
+		scalar(c, types.MakeSchemaTypeBodyU64Type(none), types.SchemaValueNodeU64Value,
+			func(b *valBuilder, v reflect.Value) int32 {
+				return b.push(types.MakeSchemaValueNodeU64Value(v.Uint()))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) { dst.SetUint(n.U64Value()) })
+
+	case reflect.Uint32:
+		scalar(c, types.MakeSchemaTypeBodyU32Type(none), types.SchemaValueNodeU32Value,
+			func(b *valBuilder, v reflect.Value) int32 {
+				return b.push(types.MakeSchemaValueNodeU32Value(uint32(v.Uint())))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) { dst.SetUint(uint64(n.U32Value())) })
+
+	case reflect.Uint16:
+		scalar(c, types.MakeSchemaTypeBodyU16Type(none), types.SchemaValueNodeU16Value,
+			func(b *valBuilder, v reflect.Value) int32 {
+				return b.push(types.MakeSchemaValueNodeU16Value(uint16(v.Uint())))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) { dst.SetUint(uint64(n.U16Value())) })
+
+	case reflect.Uint8:
+		scalar(c, types.MakeSchemaTypeBodyU8Type(none), types.SchemaValueNodeU8Value,
+			func(b *valBuilder, v reflect.Value) int32 {
+				return b.push(types.MakeSchemaValueNodeU8Value(uint8(v.Uint())))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) { dst.SetUint(uint64(n.U8Value())) })
+
+	case reflect.Float64:
+		scalar(c, types.MakeSchemaTypeBodyF64Type(none), types.SchemaValueNodeF64Value,
+			func(b *valBuilder, v reflect.Value) int32 {
+				return b.push(types.MakeSchemaValueNodeF64Value(v.Float()))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) { dst.SetFloat(n.F64Value()) })
+
+	case reflect.Float32:
+		scalar(c, types.MakeSchemaTypeBodyF32Type(none), types.SchemaValueNodeF32Value,
+			func(b *valBuilder, v reflect.Value) int32 {
+				return b.push(types.MakeSchemaValueNodeF32Value(float32(v.Float())))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) { dst.SetFloat(float64(n.F32Value())) })
+
+	case reflect.Struct:
+		d.compileRecord(c)
+
+	case reflect.Pointer:
+		// A pointer is Go's spelling of "optional". This is the same convention
+		// encoding/json, protobuf-go and serde use, so it should not surprise —
+		// but it does mean a *T used purely to avoid copying still publishes as
+		// option<T> to callers.
+		compileOption(c, d.compile(c.typ.Elem()), pointerOps(c.typ))
+
+	case reflect.Slice:
+		compileList(c, d.compile(c.typ.Elem()))
+
+	case reflect.Array:
+		compileFixedList(c, d.compile(c.typ.Elem()))
+
+	case reflect.Map:
+		d.compileMap(c)
+
+	case reflect.Int, reflect.Uint:
+		markInvalid(c, "%s has a platform-dependent width; use a sized type such as int64/uint64", c.typ)
+
+	case reflect.Interface:
+		markInvalid(c, "interface type %s is not a registered variant; declare it with golem.DefineVariant", c.typ)
+
+	default:
+		markInvalid(c, "unsupported type %s (kind %s)", c.typ, c.typ.Kind())
+	}
+}
+
+// markInvalid flags a type the SDK cannot represent and fills the codec with a
+// safe no-op body, so schema derivation itself does not panic. It records
+// nothing globally: the schema builder collects invalid codecs per agent
+// ([graphBuilder.invalids]) so the problem is attributed to the agent(s) that
+// actually use the type and reported at discovery — never as an init() trap, and
+// never poisoning an unrelated agent.
+func markInvalid(c *codec, format string, args ...any) {
+	c.invalid = fmt.Sprintf(format, args...)
+	c.body = func(*graphBuilder) types.SchemaTypeBody { return types.MakeSchemaTypeBodyBoolType() }
+	c.encode = func(b *valBuilder, _ reflect.Value) int32 {
+		return b.push(types.MakeSchemaValueNodeBoolValue(false))
+	}
+	c.decode = func(*decoder, reflect.Value, int32) error {
+		return fmt.Errorf("type %s could not be compiled (see agent definition errors)", c.typ)
+	}
+}
+
+// sdkComposite recognises the SDK's own composite types (Option, Result, ...)
+// and fills in c if c.typ is one of them.
+func (d *definitions) sdkComposite(c *codec) bool {
+	if c.typ.Kind() != reflect.Struct {
+		return false
+	}
+	zero := reflect.New(c.typ).Elem().Interface()
+
+	switch z := zero.(type) {
+	case secretish:
+		compileSecret(c, d.compile(z.secretElem()))
+		return true
+	case optionish:
+		compileOption(c, d.compile(z.optionElem()), optionValueOps())
+		return true
+	case resultish:
+		okT, errT := z.resultElems()
+		compileResult(c, d.compile(okT), d.compile(errT))
+		return true
+	}
+	return false
+}
+
+// scalar fills in a codec for a type that occupies a single node on both sides.
+// Decoding checks the tag first: the generated accessors panic on mismatch, and
+// malformed input must produce an error, not a panic.
+
+func isPrimitiveKind(k reflect.Kind) bool {
+	switch k {
+	case reflect.String, reflect.Bool,
+		reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
+		reflect.Float32, reflect.Float64:
+		return true
+	}
+	return false
+}
+
+// sortValues orders primitive map keys so encoding is deterministic.
+func sortValues(vs []reflect.Value) {
+	sort.Slice(vs, func(i, j int) bool {
+		a, b := vs[i], vs[j]
+		switch a.Kind() {
+		case reflect.String:
+			return a.String() < b.String()
+		case reflect.Bool:
+			return !a.Bool() && b.Bool()
+		case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			return a.Int() < b.Int()
+		case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			return a.Uint() < b.Uint()
+		case reflect.Float32, reflect.Float64:
+			return a.Float() < b.Float()
+		}
+		return false
+	})
+}
+
+// optionValueOps drives Option[T] through the same codec as *T, so the two
+// spellings produce identical schemas and are interchangeable.
diff --git a/sdks/go/golem/codec_aggregate.go b/sdks/go/golem/codec_aggregate.go
new file mode 100644
index 0000000000..3b6ef656bc
--- /dev/null
+++ b/sdks/go/golem/codec_aggregate.go
@@ -0,0 +1,394 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"fmt"
+	"reflect"
+	"time"
+
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+func (d *definitions) compileRecord(c *codec) {
+	fields := d.structFields(c.typ)
+
+	c.body = func(g *graphBuilder) types.SchemaTypeBody {
+		nf := make([]types.NamedFieldType, 0, len(fields))
+		for _, f := range fields {
+			nf = append(nf, types.NamedFieldType{Name: f.name, Body: g.node(f.codec)})
+		}
+		return types.MakeSchemaTypeBodyRecordType(nf)
+	}
+
+	c.encode = func(b *valBuilder, v reflect.Value) int32 {
+		// Children are appended first; the record node then refers to them.
+		idxs := make([]int32, 0, len(fields))
+		for _, f := range fields {
+			idxs = append(idxs, f.codec.encode(b, v.Field(f.index)))
+		}
+		return b.push(types.MakeSchemaValueNodeRecordValue(idxs))
+	}
+
+	c.decode = func(d *decoder, dst reflect.Value, idx int32) error {
+		n, err := d.node(idx)
+		if err != nil {
+			return err
+		}
+		if n.Tag() != types.SchemaValueNodeRecordValue {
+			return fmt.Errorf("cannot decode value node (tag %d) into %s", n.Tag(), c.typ)
+		}
+		idxs := n.RecordValue()
+		if len(idxs) < len(fields) {
+			return fmt.Errorf("record for %s has %d field(s), want %d", c.typ, len(idxs), len(fields))
+		}
+		for i, f := range fields {
+			if err := f.codec.decode(d, dst.Field(f.index), idxs[i]); err != nil {
+				return fmt.Errorf("%s.%s: %w", c.typ, f.name, err)
+			}
+		}
+		return nil
+	}
+}
+
+// ---------------------------------------------------------------------------
+// containers
+// ---------------------------------------------------------------------------
+
+// optionOps abstracts the two Go spellings of an optional value, so *T and
+// Option[T] share one codec and therefore produce identical schemas.
+
+func compileList(c *codec, elem *codec) {
+	c.body = func(g *graphBuilder) types.SchemaTypeBody {
+		return types.MakeSchemaTypeBodyListType(g.node(elem))
+	}
+	c.encode = func(b *valBuilder, v reflect.Value) int32 {
+		idxs := make([]int32, 0, v.Len())
+		for i := range v.Len() {
+			idxs = append(idxs, elem.encode(b, v.Index(i)))
+		}
+		return b.push(types.MakeSchemaValueNodeListValue(idxs))
+	}
+	c.decode = func(d *decoder, dst reflect.Value, idx int32) error {
+		n, err := d.node(idx)
+		if err != nil {
+			return err
+		}
+		if n.Tag() != types.SchemaValueNodeListValue {
+			return fmt.Errorf("cannot decode value node (tag %d) into %s", n.Tag(), c.typ)
+		}
+		idxs := n.ListValue()
+		out := reflect.MakeSlice(c.typ, len(idxs), len(idxs))
+		for i, child := range idxs {
+			if err := elem.decode(d, out.Index(i), child); err != nil {
+				return fmt.Errorf("%s[%d]: %w", c.typ, i, err)
+			}
+		}
+		dst.Set(out)
+		return nil
+	}
+}
+
+// compileFixedList handles Go arrays, whose length is part of the type.
+func compileFixedList(c *codec, elem *codec) {
+	n := c.typ.Len()
+	c.body = func(g *graphBuilder) types.SchemaTypeBody {
+		return types.MakeSchemaTypeBodyFixedListType(types.FixedListSpec{
+			Element: g.node(elem),
+			Length:  uint32(n),
+		})
+	}
+	c.encode = func(b *valBuilder, v reflect.Value) int32 {
+		idxs := make([]int32, 0, n)
+		for i := range n {
+			idxs = append(idxs, elem.encode(b, v.Index(i)))
+		}
+		return b.push(types.MakeSchemaValueNodeFixedListValue(idxs))
+	}
+	c.decode = func(d *decoder, dst reflect.Value, idx int32) error {
+		node, err := d.node(idx)
+		if err != nil {
+			return err
+		}
+		if node.Tag() != types.SchemaValueNodeFixedListValue {
+			return fmt.Errorf("cannot decode value node (tag %d) into %s", node.Tag(), c.typ)
+		}
+		idxs := node.FixedListValue()
+		if len(idxs) != n {
+			return fmt.Errorf("fixed list for %s has %d element(s), want %d", c.typ, len(idxs), n)
+		}
+		for i, child := range idxs {
+			if err := elem.decode(d, dst.Index(i), child); err != nil {
+				return fmt.Errorf("%s[%d]: %w", c.typ, i, err)
+			}
+		}
+		return nil
+	}
+}
+
+func (d *definitions) compileMap(c *codec) {
+	kt, vt := c.typ.Key(), c.typ.Elem()
+	if !isPrimitiveKind(kt.Kind()) {
+		markInvalid(c, "map key type %s is not a primitive; WIT restricts map keys to primitives", kt)
+		return
+	}
+	key, val := d.compile(kt), d.compile(vt)
+
+	c.body = func(g *graphBuilder) types.SchemaTypeBody {
+		return types.MakeSchemaTypeBodyMapType(types.MapSpec{Key: g.node(key), Value: g.node(val)})
+	}
+	c.encode = func(b *valBuilder, v reflect.Value) int32 {
+		// Go randomizes map iteration order. Encoding must be deterministic:
+		// these trees are recorded in the oplog and compared on replay.
+		keys := v.MapKeys()
+		sortValues(keys)
+		entries := make([]types.MapEntry, 0, len(keys))
+		for _, k := range keys {
+			ki := key.encode(b, k)
+			vi := val.encode(b, v.MapIndex(k))
+			entries = append(entries, types.MapEntry{Key: ki, Value: vi})
+		}
+		return b.push(types.MakeSchemaValueNodeMapValue(entries))
+	}
+	c.decode = func(d *decoder, dst reflect.Value, idx int32) error {
+		n, err := d.node(idx)
+		if err != nil {
+			return err
+		}
+		if n.Tag() != types.SchemaValueNodeMapValue {
+			return fmt.Errorf("cannot decode value node (tag %d) into %s", n.Tag(), c.typ)
+		}
+		out := reflect.MakeMap(c.typ)
+		for i, e := range n.MapValue() {
+			k := reflect.New(kt).Elem()
+			if err := key.decode(d, k, e.Key); err != nil {
+				return fmt.Errorf("%s key %d: %w", c.typ, i, err)
+			}
+			v := reflect.New(vt).Elem()
+			if err := val.decode(d, v, e.Value); err != nil {
+				return fmt.Errorf("%s value %d: %w", c.typ, i, err)
+			}
+			out.SetMapIndex(k, v)
+		}
+		dst.Set(out)
+		return nil
+	}
+}
+
+func compileResult(c *codec, okC, errC *codec) {
+	c.body = func(g *graphBuilder) types.SchemaTypeBody {
+		return types.MakeSchemaTypeBodyResultType(types.ResultSpec{
+			Ok:  witTypes.Some(g.node(okC)),
+			Err: witTypes.Some(g.node(errC)),
+		})
+	}
+	c.encode = func(b *valBuilder, v reflect.Value) int32 {
+		inner, isErr := v.Interface().(resultish).resultGet()
+		if isErr {
+			i := errC.encode(b, inner)
+			return b.push(types.MakeSchemaValueNodeResultValue(
+				types.MakeResultValuePayloadErrValue(witTypes.Some(i))))
+		}
+		i := okC.encode(b, inner)
+		return b.push(types.MakeSchemaValueNodeResultValue(
+			types.MakeResultValuePayloadOkValue(witTypes.Some(i))))
+	}
+	c.decode = func(d *decoder, dst reflect.Value, idx int32) error {
+		n, err := d.node(idx)
+		if err != nil {
+			return err
+		}
+		if n.Tag() != types.SchemaValueNodeResultValue {
+			return fmt.Errorf("cannot decode value node (tag %d) into %s", n.Tag(), c.typ)
+		}
+		setter := dst.Addr().Interface().(resultSetter)
+		payload := n.ResultValue()
+		if payload.Tag() == types.ResultValuePayloadErrValue {
+			child := payload.ErrValue()
+			if child.IsNone() {
+				return fmt.Errorf("%s: err arm carries no value", c.typ)
+			}
+			return errC.decode(d, setter.resultSetErr(), child.Some())
+		}
+		child := payload.OkValue()
+		if child.IsNone() {
+			return fmt.Errorf("%s: ok arm carries no value", c.typ)
+		}
+		return okC.decode(d, setter.resultSetOk(), child.Some())
+	}
+}
+
+// ---------------------------------------------------------------------------
+// variants and enums
+// ---------------------------------------------------------------------------
+
+func (d *definitions) compileVariant(c *codec, vd *variantDef) {
+	caseCodecs := make([]*codec, len(vd.cases))
+	byType := make(map[reflect.Type]int, len(vd.cases))
+	for i, cs := range vd.cases {
+		caseCodecs[i] = d.compile(cs.typ)
+		byType[cs.typ] = i
+	}
+
+	c.body = func(g *graphBuilder) types.SchemaTypeBody {
+		out := make([]types.VariantCaseType, 0, len(vd.cases))
+		for i, cs := range vd.cases {
+			out = append(out, types.VariantCaseType{
+				Name:    cs.name,
+				Payload: witTypes.Some(g.node(caseCodecs[i])),
+			})
+		}
+		return types.MakeSchemaTypeBodyVariantType(out)
+	}
+
+	c.encode = func(b *valBuilder, v reflect.Value) int32 {
+		concrete := v
+		if v.Kind() == reflect.Interface {
+			if v.IsNil() {
+				panic(&encodeError{fmt.Sprintf("nil %s cannot be encoded; a variant must hold one of its cases", c.typ)})
+			}
+			concrete = v.Elem()
+		}
+		i, ok := byType[concrete.Type()]
+		if !ok {
+			panic(&encodeError{fmt.Sprintf("%s is not a registered case of variant %s", concrete.Type(), c.typ)})
+		}
+		payload := caseCodecs[i].encode(b, concrete)
+		return b.push(types.MakeSchemaValueNodeVariantValue(types.VariantValuePayload{
+			Case:    uint32(i),
+			Payload: witTypes.Some(payload),
+		}))
+	}
+
+	c.decode = func(dec *decoder, dst reflect.Value, idx int32) error {
+		n, err := dec.node(idx)
+		if err != nil {
+			return err
+		}
+		if n.Tag() != types.SchemaValueNodeVariantValue {
+			return fmt.Errorf("cannot decode value node (tag %d) into %s", n.Tag(), c.typ)
+		}
+		p := n.VariantValue()
+		if int(p.Case) >= len(vd.cases) {
+			return fmt.Errorf("%s: case index %d out of range (%d cases)", c.typ, p.Case, len(vd.cases))
+		}
+		if p.Payload.IsNone() {
+			return fmt.Errorf("%s: case %q carries no payload", c.typ, vd.cases[p.Case].name)
+		}
+		out := reflect.New(vd.cases[p.Case].typ).Elem()
+		if err := caseCodecs[p.Case].decode(dec, out, p.Payload.Some()); err != nil {
+			return fmt.Errorf("%s case %q: %w", c.typ, vd.cases[p.Case].name, err)
+		}
+		dst.Set(out)
+		return nil
+	}
+}
+
+func compileEnum(c *codec, d *enumDef) {
+	signed := false
+	switch c.typ.Kind() {
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		signed = true
+	}
+
+	c.body = func(*graphBuilder) types.SchemaTypeBody {
+		return types.MakeSchemaTypeBodyEnumType(d.names)
+	}
+	c.encode = func(b *valBuilder, v reflect.Value) int32 {
+		var i int64
+		if signed {
+			i = v.Int()
+		} else {
+			i = int64(v.Uint())
+		}
+		if i < 0 || int(i) >= len(d.names) {
+			panic(&encodeError{fmt.Sprintf("%s value %d is outside the declared enum range 0..%d",
+				c.typ, i, len(d.names)-1)})
+		}
+		return b.push(types.MakeSchemaValueNodeEnumValue(uint32(i)))
+	}
+	c.decode = func(dec *decoder, dst reflect.Value, idx int32) error {
+		n, err := dec.node(idx)
+		if err != nil {
+			return err
+		}
+		if n.Tag() != types.SchemaValueNodeEnumValue {
+			return fmt.Errorf("cannot decode value node (tag %d) into %s", n.Tag(), c.typ)
+		}
+		i := n.EnumValue()
+		if int(i) >= len(d.names) {
+			return fmt.Errorf("%s: enum index %d out of range (%d names)", c.typ, i, len(d.names))
+		}
+		if signed {
+			dst.SetInt(int64(i))
+		} else {
+			dst.SetUint(uint64(i))
+		}
+		return nil
+	}
+}
+
+// ---------------------------------------------------------------------------
+// named types and markers
+// ---------------------------------------------------------------------------
+
+// namedTypeCodecs holds the types recognised by identity rather than by kind:
+// each has a Go representation indistinguishable from a primitive, so only the
+// named type reveals the intent.
+var namedTypeCodecs = map[reflect.Type]func(*codec){
+	reflect.TypeFor[Char](): func(c *codec) {
+		scalar(c, types.MakeSchemaTypeBodyCharType(), types.SchemaValueNodeCharValue,
+			func(b *valBuilder, v reflect.Value) int32 {
+				return b.push(types.MakeSchemaValueNodeCharValue(rune(v.Int())))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) { dst.SetInt(int64(n.CharValue())) })
+	},
+	reflect.TypeFor[URL](): func(c *codec) {
+		scalar(c, types.MakeSchemaTypeBodyUrlType(types.UrlRestrictions{
+			AllowedSchemes: witTypes.None[[]string](),
+			AllowedHosts:   witTypes.None[[]string](),
+		}), types.SchemaValueNodeUrlValue,
+			func(b *valBuilder, v reflect.Value) int32 {
+				return b.push(types.MakeSchemaValueNodeUrlValue(v.String()))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) { dst.SetString(n.UrlValue()) })
+	},
+	reflect.TypeFor[time.Time](): func(c *codec) {
+		scalar(c, types.MakeSchemaTypeBodyDatetimeType(), types.SchemaValueNodeDatetimeValue,
+			func(b *valBuilder, v reflect.Value) int32 {
+				t := v.Interface().(time.Time)
+				return b.push(types.MakeSchemaValueNodeDatetimeValue(types.Datetime{
+					Seconds:     t.Unix(),
+					Nanoseconds: uint32(t.Nanosecond()),
+				}))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) {
+				d := n.DatetimeValue()
+				// UTC, so a round trip is stable: the wire carries no zone.
+				dst.Set(reflect.ValueOf(time.Unix(d.Seconds, int64(d.Nanoseconds)).UTC()))
+			})
+	},
+	reflect.TypeFor[time.Duration](): func(c *codec) {
+		scalar(c, types.MakeSchemaTypeBodyDurationType(), types.SchemaValueNodeDurationValue,
+			func(b *valBuilder, v reflect.Value) int32 {
+				return b.push(types.MakeSchemaValueNodeDurationValue(
+					types.DurationValuePayload{Nanoseconds: v.Int()}))
+			},
+			func(dst reflect.Value, n types.SchemaValueNode) {
+				dst.SetInt(n.DurationValue().Nanoseconds)
+			})
+	},
+}
diff --git a/sdks/go/golem/codec_scalar.go b/sdks/go/golem/codec_scalar.go
new file mode 100644
index 0000000000..01d6c8f9ad
--- /dev/null
+++ b/sdks/go/golem/codec_scalar.go
@@ -0,0 +1,140 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"fmt"
+	"reflect"
+
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+func scalar(
+	c *codec,
+	body types.SchemaTypeBody,
+	tag uint8,
+	enc func(*valBuilder, reflect.Value) int32,
+	set func(reflect.Value, types.SchemaValueNode),
+) {
+	c.body = func(*graphBuilder) types.SchemaTypeBody { return body }
+	c.encode = enc
+	c.decode = func(d *decoder, dst reflect.Value, idx int32) error {
+		n, err := d.node(idx)
+		if err != nil {
+			return err
+		}
+		if n.Tag() != tag {
+			return fmt.Errorf("cannot decode value node (tag %d) into %s", n.Tag(), c.typ)
+		}
+		set(dst, n)
+		return nil
+	}
+}
+
+// compileRecord handles Go structs, which lower to WIT records. Fields are
+// positional on the wire: declaration order is the order the schema reports and
+// the order values are written in.
+
+type optionOps struct {
+	// get reports whether the value is present, and if so yields the inner value.
+	get func(v reflect.Value) (reflect.Value, bool)
+	// setNone clears dst.
+	setNone func(dst reflect.Value)
+	// setSome prepares dst to hold a value and returns the slot to decode into.
+	setSome func(dst reflect.Value) reflect.Value
+}
+
+func pointerOps(t reflect.Type) optionOps {
+	return optionOps{
+		get: func(v reflect.Value) (reflect.Value, bool) {
+			if v.IsNil() {
+				return reflect.Value{}, false
+			}
+			return v.Elem(), true
+		},
+		setNone: func(dst reflect.Value) { dst.Set(reflect.Zero(t)) },
+		setSome: func(dst reflect.Value) reflect.Value {
+			p := reflect.New(t.Elem())
+			dst.Set(p)
+			return p.Elem()
+		},
+	}
+}
+
+func compileOption(c *codec, inner *codec, ops optionOps) {
+	c.body = func(g *graphBuilder) types.SchemaTypeBody {
+		return types.MakeSchemaTypeBodyOptionType(g.node(inner))
+	}
+	c.encode = func(b *valBuilder, v reflect.Value) int32 {
+		if in, some := ops.get(v); some {
+			idx := inner.encode(b, in)
+			return b.push(types.MakeSchemaValueNodeOptionValue(witTypes.Some(idx)))
+		}
+		return b.push(types.MakeSchemaValueNodeOptionValue(witTypes.None[int32]()))
+	}
+	c.decode = func(d *decoder, dst reflect.Value, idx int32) error {
+		n, err := d.node(idx)
+		if err != nil {
+			return err
+		}
+		if n.Tag() != types.SchemaValueNodeOptionValue {
+			return fmt.Errorf("cannot decode value node (tag %d) into %s", n.Tag(), c.typ)
+		}
+		opt := n.OptionValue()
+		if opt.IsNone() {
+			ops.setNone(dst)
+			return nil
+		}
+		return inner.decode(d, ops.setSome(dst), opt.Some())
+	}
+}
+
+func optionValueOps() optionOps {
+	return optionOps{
+		get: func(v reflect.Value) (reflect.Value, bool) {
+			return v.Interface().(optionish).optionGet()
+		},
+		setNone: func(dst reflect.Value) {
+			dst.Addr().Interface().(optionSetter).optionSetNone()
+		},
+		setSome: func(dst reflect.Value) reflect.Value {
+			return dst.Addr().Interface().(optionSetter).optionSetSome()
+		},
+	}
+}
+
+func compileSecret(c *codec, inner *codec) {
+	// Schema side only: emit the secret(inner) type node. This is what the config
+	// graph and the config-metadata declaration need. inner is compiled so the
+	// node references the revealed type.
+	c.body = func(g *graphBuilder) types.SchemaTypeBody {
+		return types.MakeSchemaTypeBodySecretType(types.SecretSpec{
+			Inner:    g.node(inner),
+			Category: witTypes.None[string](),
+		})
+	}
+	// Secrets are config-only: they are read via get-config-value + reveal (see
+	// readSecretValue), never carried as plaintext in an invocation payload. Guard
+	// the wire path so using a Secret[T] as a method parameter/return fails clearly
+	// instead of silently shipping plaintext. Config never reaches these — it uses
+	// c.body for the graph and reveal for the value.
+	c.encode = func(*valBuilder, reflect.Value) int32 {
+		panic(&encodeError{"Secret[T] is config-only; it cannot be a method parameter or return value"})
+	}
+	c.decode = func(*decoder, reflect.Value, int32) error {
+		return fmt.Errorf("golem: Secret[T] is config-only; it cannot be a method parameter or return value")
+	}
+}
diff --git a/sdks/go/golem/codec_test.go b/sdks/go/golem/codec_test.go
new file mode 100644
index 0000000000..faa9134945
--- /dev/null
+++ b/sdks/go/golem/codec_test.go
@@ -0,0 +1,875 @@
+package golem
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+)
+
+// ---------------------------------------------------------------------------
+// schema / value agreement
+// ---------------------------------------------------------------------------
+
+// checkAgreement walks a type graph and a value tree together and asserts every
+// value node matches the schema node describing it — same kind, same arity.
+//
+// This is the property the codec design exists to guarantee. Encoding, decoding
+// and schema derivation used to be three separate walks that had to agree by
+// convention; now they are built together per type, and this check is what
+// proves it for every case exercised below.
+func checkAgreement(g types.SchemaGraph, sIdx int32, tree types.SchemaValueTree, vIdx int32, path string) error {
+	if int(sIdx) >= len(g.TypeNodes) {
+		return fmt.Errorf("%s: type index %d out of range", path, sIdx)
+	}
+	if int(vIdx) >= len(tree.ValueNodes) {
+		return fmt.Errorf("%s: value index %d out of range", path, vIdx)
+	}
+	body := g.TypeNodes[sIdx].Body
+	val := tree.ValueNodes[vIdx]
+
+	mismatch := func() error {
+		return fmt.Errorf("%s: value tag %d does not match schema tag %d", path, val.Tag(), body.Tag())
+	}
+
+	switch body.Tag() {
+	case types.SchemaTypeBodyRecordType:
+		if val.Tag() != types.SchemaValueNodeRecordValue {
+			return mismatch()
+		}
+		fields, children := body.RecordType(), val.RecordValue()
+		if len(fields) != len(children) {
+			return fmt.Errorf("%s: record has %d value(s) but schema declares %d field(s)",
+				path, len(children), len(fields))
+		}
+		for i, f := range fields {
+			if err := checkAgreement(g, f.Body, tree, children[i], path+"."+f.Name); err != nil {
+				return err
+			}
+		}
+	case types.SchemaTypeBodyOptionType:
+		if val.Tag() != types.SchemaValueNodeOptionValue {
+			return mismatch()
+		}
+		if inner := val.OptionValue(); inner.IsSome() {
+			return checkAgreement(g, body.OptionType(), tree, inner.Some(), path+"?")
+		}
+	case types.SchemaTypeBodyResultType:
+		if val.Tag() != types.SchemaValueNodeResultValue {
+			return mismatch()
+		}
+		spec, payload := body.ResultType(), val.ResultValue()
+		if payload.Tag() == types.ResultValuePayloadErrValue {
+			if c := payload.ErrValue(); c.IsSome() {
+				return checkAgreement(g, spec.Err.Some(), tree, c.Some(), path+".err")
+			}
+		} else if c := payload.OkValue(); c.IsSome() {
+			return checkAgreement(g, spec.Ok.Some(), tree, c.Some(), path+".ok")
+		}
+	case types.SchemaTypeBodyListType:
+		if val.Tag() != types.SchemaValueNodeListValue {
+			return mismatch()
+		}
+		for i, child := range val.ListValue() {
+			if err := checkAgreement(g, body.ListType(), tree, child, fmt.Sprintf("%s[%d]", path, i)); err != nil {
+				return err
+			}
+		}
+	case types.SchemaTypeBodyFixedListType:
+		if val.Tag() != types.SchemaValueNodeFixedListValue {
+			return mismatch()
+		}
+		spec, children := body.FixedListType(), val.FixedListValue()
+		if int(spec.Length) != len(children) {
+			return fmt.Errorf("%s: fixed list has %d element(s), schema declares %d",
+				path, len(children), spec.Length)
+		}
+		for i, child := range children {
+			if err := checkAgreement(g, spec.Element, tree, child, fmt.Sprintf("%s[%d]", path, i)); err != nil {
+				return err
+			}
+		}
+	case types.SchemaTypeBodyMapType:
+		if val.Tag() != types.SchemaValueNodeMapValue {
+			return mismatch()
+		}
+		spec := body.MapType()
+		for i, e := range val.MapValue() {
+			if err := checkAgreement(g, spec.Key, tree, e.Key, fmt.Sprintf("%s.key%d", path, i)); err != nil {
+				return err
+			}
+			if err := checkAgreement(g, spec.Value, tree, e.Value, fmt.Sprintf("%s.val%d", path, i)); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// roundTrip encodes in, verifies the tree agrees with the derived schema, then
+// decodes it back.
+func roundTrip[T any](t *testing.T, in T) T {
+	t.Helper()
+	c := defs.compile(reflect.TypeFor[T]())
+
+	// &in, not in: reflect.ValueOf would unwrap an interface-typed T to its
+	// concrete type, which is exactly what a variant must not lose.
+	tree := encodeWith(c, reflect.ValueOf(&in).Elem())
+
+	g := graphBuilder{d: defs}
+	root := g.node(c)
+	if err := checkAgreement(g.build(), root, tree, tree.Root, reflect.TypeFor[T]().String()); err != nil {
+		t.Fatalf("schema/value disagreement: %v", err)
+	}
+
+	out := reflect.New(reflect.TypeFor[T]()).Elem()
+	d := decoder{nodes: tree.ValueNodes}
+	if err := c.decode(&d, out, tree.Root); err != nil {
+		t.Fatalf("decode failed: %v", err)
+	}
+	return out.Interface().(T)
+}
+
+func assertRoundTrip[T any](t *testing.T, name string, in T) {
+	t.Helper()
+	if got := roundTrip(t, in); !reflect.DeepEqual(got, in) {
+		t.Errorf("%s: round trip changed the value\n got: %#v\nwant: %#v", name, got, in)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// types under test
+// ---------------------------------------------------------------------------
+
+type Money struct {
+	Amount   int64
+	Currency string
+}
+
+type Line struct {
+	Sku string
+	Qty int32
+}
+
+type Order struct {
+	ID     string
+	Coupon *string
+	Lines  []Line
+	Refund Option[Result[Money, string]]
+	Tags   map[string]int64
+	Digits [3]uint8
+}
+
+func TestRoundTripPrimitivesAndRecords(t *testing.T) {
+	assertRoundTrip(t, "string", "hello")
+	assertRoundTrip(t, "bool", true)
+	assertRoundTrip(t, "int64", int64(-9000))
+	assertRoundTrip(t, "uint8", uint8(255))
+	assertRoundTrip(t, "float64", 3.5)
+	assertRoundTrip(t, "record", Money{Amount: 1050, Currency: "EUR"})
+}
+
+func TestRoundTripNestedComposites(t *testing.T) {
+	coupon := "SUMMER"
+	full := Order{
+		ID:     "ord-1",
+		Coupon: &coupon,
+		Lines:  []Line{{Sku: "a", Qty: 2}, {Sku: "b", Qty: 1}},
+		Refund: Some(Ok[Money, string](Money{Amount: 250, Currency: "EUR"})),
+		Tags:   map[string]int64{"priority": 1, "region": 7},
+		Digits: [3]uint8{1, 2, 3},
+	}
+	assertRoundTrip(t, "order (all present)", full)
+
+	// The absent/failed shapes must round-trip too.
+	empty := Order{
+		ID:     "ord-2",
+		Coupon: nil,
+		Lines:  []Line{},
+		Refund: None[Result[Money, string]](),
+		Tags:   map[string]int64{},
+		Digits: [3]uint8{},
+	}
+	assertRoundTrip(t, "order (all absent)", empty)
+
+	failed := full
+	failed.Refund = Some(Err[Money, string]("card expired"))
+	assertRoundTrip(t, "order (result is err)", failed)
+}
+
+func TestRoundTripDeeplyNestedOptionAndResult(t *testing.T) {
+	// The shapes that motivated the codec design: options of results, results of
+	// options, options of options, and lists of each.
+	assertRoundTrip(t, "option<option<string>>", Some(Some("x")))
+	assertRoundTrip(t, "option<option<string>> inner none", Some(None[string]()))
+	assertRoundTrip(t, "option<option<string>> outer none", None[Option[string]]())
+	assertRoundTrip(t, "**string via pointers", func() **string {
+		s := "deep"
+		p := &s
+		return &p
+	}())
+	assertRoundTrip(t, "result<option<Money>, string>",
+		Ok[Option[Money], string](Some(Money{Amount: 1, Currency: "GBP"})))
+	assertRoundTrip(t, "result<result<..>>",
+		Ok[Result[int64, string], string](Err[int64, string]("inner")))
+	assertRoundTrip(t, "list<option<result<..>>>", []Option[Result[Money, string]]{
+		Some(Ok[Money, string](Money{Amount: 5, Currency: "USD"})),
+		None[Result[Money, string]](),
+		Some(Err[Money, string]("nope")),
+	})
+	assertRoundTrip(t, "map<string, list<option<int64>>>", map[string][]Option[int64]{
+		"a": {Some(int64(1)), None[int64]()},
+		"b": {},
+	})
+}
+
+// TestPointerAndOptionProduceTheSameSchema — *T and Option[T] are two spellings of the same thing, so they must produce
+// byte-identical schemas.
+func TestPointerAndOptionProduceTheSameSchema(t *testing.T) {
+	schemaOf := func(rt reflect.Type) types.SchemaGraph {
+		g := graphBuilder{d: defs}
+		g.node(defs.compile(rt))
+		return g.build()
+	}
+	ptr := schemaOf(reflect.TypeFor[*string]())
+	opt := schemaOf(reflect.TypeFor[Option[string]]())
+
+	if len(ptr.TypeNodes) != len(opt.TypeNodes) {
+		t.Fatalf("node counts differ: *string=%d Option[string]=%d", len(ptr.TypeNodes), len(opt.TypeNodes))
+	}
+	for i := range ptr.TypeNodes {
+		if a, b := ptr.TypeNodes[i].Body.Tag(), opt.TypeNodes[i].Body.Tag(); a != b {
+			t.Fatalf("node %d differs: *string tag %d, Option[string] tag %d", i, a, b)
+		}
+	}
+	// node 0 is the option (its index is reserved before the inner type is added)
+	if ptr.TypeNodes[0].Body.Tag() != types.SchemaTypeBodyOptionType {
+		t.Fatal("expected an option-type node at the root")
+	}
+	if ptr.TypeNodes[1].Body.Tag() != types.SchemaTypeBodyStringType {
+		t.Fatal("expected the inner string type")
+	}
+}
+
+// ---------------------------------------------------------------------------
+// recursion
+// ---------------------------------------------------------------------------
+
+type Tree struct {
+	Label    string
+	Children []*Tree
+}
+
+// assertNoCycleWithoutRef mirrors the consumer's own validation: it walks the
+// type nodes exactly as golem-schema's decoder does, tracking the nodes on the
+// current path. Re-entering a node without passing through a ref-type is
+// DecodeError::CyclicTypeWithoutRef — a graph the platform rejects outright.
+// ref-type deliberately does not recurse into the def body, which is what makes
+// it the only valid recursion form.
+func assertNoCycleWithoutRef(t *testing.T, g types.SchemaGraph, idx int32, path map[int32]bool) {
+	t.Helper()
+	if path[idx] {
+		t.Fatalf("node %d re-entered without passing through a ref-type: "+
+			"this graph would be rejected as CyclicTypeWithoutRef", idx)
+	}
+	path[idx] = true
+	defer delete(path, idx)
+
+	body := g.TypeNodes[idx].Body
+	switch body.Tag() {
+	case types.SchemaTypeBodyRefType:
+		return // a reference terminates the walk
+	case types.SchemaTypeBodyRecordType:
+		for _, f := range body.RecordType() {
+			assertNoCycleWithoutRef(t, g, f.Body, path)
+		}
+	case types.SchemaTypeBodyVariantType:
+		for _, c := range body.VariantType() {
+			if c.Payload.IsSome() {
+				assertNoCycleWithoutRef(t, g, c.Payload.Some(), path)
+			}
+		}
+	case types.SchemaTypeBodyOptionType:
+		assertNoCycleWithoutRef(t, g, body.OptionType(), path)
+	case types.SchemaTypeBodyListType:
+		assertNoCycleWithoutRef(t, g, body.ListType(), path)
+	case types.SchemaTypeBodyFixedListType:
+		assertNoCycleWithoutRef(t, g, body.FixedListType().Element, path)
+	case types.SchemaTypeBodyMapType:
+		spec := body.MapType()
+		assertNoCycleWithoutRef(t, g, spec.Key, path)
+		assertNoCycleWithoutRef(t, g, spec.Value, path)
+	case types.SchemaTypeBodyResultType:
+		spec := body.ResultType()
+		if spec.Ok.IsSome() {
+			assertNoCycleWithoutRef(t, g, spec.Ok.Some(), path)
+		}
+		if spec.Err.IsSome() {
+			assertNoCycleWithoutRef(t, g, spec.Err.Some(), path)
+		}
+	}
+}
+
+func TestRecursiveTypeIsEmittedAsANamedDefNotARawCycle(t *testing.T) {
+	c := defs.compile(reflect.TypeFor[Tree]())
+	if !c.recursive {
+		t.Fatal("Tree should have been detected as recursive at compile time")
+	}
+
+	g := graphBuilder{d: defs}
+	root := g.node(c)
+	graph := g.build()
+
+	// The root of a recursive type is a reference to its def.
+	if tag := graph.TypeNodes[root].Body.Tag(); tag != types.SchemaTypeBodyRefType {
+		t.Fatalf("root node tag = %d, want ref-type", tag)
+	}
+	if len(graph.Defs) != 1 {
+		t.Fatalf("expected exactly 1 def, got %d", len(graph.Defs))
+	}
+	def := graph.Defs[0]
+	if def.Id == "" {
+		t.Fatal("def must carry a stable type-id")
+	}
+	if !strings.HasSuffix(def.Id, ".Tree") {
+		t.Fatalf("type-id %q should end in .Tree", def.Id)
+	}
+	// The def body is the record itself, not another reference.
+	if tag := graph.TypeNodes[def.Body].Body.Tag(); tag != types.SchemaTypeBodyRecordType {
+		t.Fatalf("def body tag = %d, want record-type", tag)
+	}
+
+	// The whole graph must satisfy the consumer's rule, from the root and from
+	// every def body.
+	assertNoCycleWithoutRef(t, graph, root, map[int32]bool{})
+	for _, d := range graph.Defs {
+		assertNoCycleWithoutRef(t, graph, d.Body, map[int32]bool{})
+	}
+
+	assertRoundTrip(t, "recursive tree", Tree{
+		Label: "root",
+		Children: []*Tree{
+			{Label: "a", Children: []*Tree{{Label: "a1", Children: []*Tree{}}}},
+			{Label: "b", Children: []*Tree{}},
+		},
+	})
+}
+
+// nodeA — Mutually recursive types: marking one member of each cycle is enough, since
+// its ref-type node breaks every path through the cycle.
+type nodeA struct {
+	Name string
+	B    *nodeB
+}
+type nodeB struct {
+	Count int64
+	A     []nodeA
+}
+
+func TestMutuallyRecursiveTypesBreakTheCycle(t *testing.T) {
+	g := graphBuilder{d: defs}
+	root := g.node(defs.compile(reflect.TypeFor[nodeA]()))
+	graph := g.build()
+
+	assertNoCycleWithoutRef(t, graph, root, map[int32]bool{})
+	for _, d := range graph.Defs {
+		assertNoCycleWithoutRef(t, graph, d.Body, map[int32]bool{})
+	}
+	if len(graph.Defs) == 0 {
+		t.Fatal("a mutually recursive pair must produce at least one named def")
+	}
+	assertRoundTrip(t, "mutually recursive", nodeA{
+		Name: "a", B: &nodeB{Count: 2, A: []nodeA{{Name: "inner"}}},
+	})
+}
+
+// TestPublishedAgentSchemasHaveNoRawCycles — Every schema the SDK publishes must satisfy the rule, not just the ones with
+// obvious cycles.
+func TestPublishedAgentSchemasHaveNoRawCycles(t *testing.T) {
+	for _, name := range defs.order {
+		at, _ := defs.buildAgentType(defs.agents[name])
+		for _, f := range at.Constructor.InputSchema.Parameters() {
+			assertNoCycleWithoutRef(t, at.Schema, f.Schema, map[int32]bool{})
+		}
+		for _, m := range at.Methods {
+			for _, f := range m.InputSchema.Parameters() {
+				assertNoCycleWithoutRef(t, at.Schema, f.Schema, map[int32]bool{})
+			}
+			if m.OutputSchema.Tag() == common.OutputSchemaSingle {
+				assertNoCycleWithoutRef(t, at.Schema, m.OutputSchema.Single(), map[int32]bool{})
+			}
+		}
+		for _, d := range at.Schema.Defs {
+			assertNoCycleWithoutRef(t, at.Schema, d.Body, map[int32]bool{})
+		}
+	}
+}
+
+func TestDefsAreSortedForDeterminism(t *testing.T) {
+	g := graphBuilder{d: defs}
+	g.node(defs.compile(reflect.TypeFor[nodeA]()))
+	g.node(defs.compile(reflect.TypeFor[Tree]()))
+	graph := g.build()
+
+	for i := 1; i < len(graph.Defs); i++ {
+		if graph.Defs[i-1].Id > graph.Defs[i].Id {
+			t.Fatalf("defs not sorted: %q before %q", graph.Defs[i-1].Id, graph.Defs[i].Id)
+		}
+	}
+	// and the ref nodes still resolve to the right defs after the sort
+	for _, n := range graph.TypeNodes {
+		if n.Body.Tag() == types.SchemaTypeBodyRefType {
+			if int(n.Body.RefType()) >= len(graph.Defs) {
+				t.Fatalf("ref-type index %d out of range after sorting", n.Body.RefType())
+			}
+		}
+	}
+}
+
+func TestSharedTypeIsEmittedOnce(t *testing.T) {
+	type Pair struct {
+		Left  Money
+		Right Money
+	}
+	g := graphBuilder{d: defs}
+	g.node(defs.compile(reflect.TypeFor[Pair]()))
+	graph := g.build()
+
+	records := 0
+	for _, n := range graph.TypeNodes {
+		if n.Body.Tag() == types.SchemaTypeBodyRecordType {
+			records++
+		}
+	}
+	// Pair and Money — Money must not be duplicated for each field.
+	if records != 2 {
+		t.Fatalf("expected 2 record nodes (Pair, Money), got %d", records)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// determinism and rejection
+// ---------------------------------------------------------------------------
+
+func TestMapEncodingIsDeterministic(t *testing.T) {
+	// Go randomizes map iteration; these trees land in the oplog and are
+	// compared on replay, so encoding must be stable.
+	m := map[string]int64{"z": 1, "a": 2, "m": 3, "b": 4, "q": 5}
+	c := defs.compile(reflect.TypeFor[map[string]int64]())
+
+	first := encodeWith(c, reflect.ValueOf(m))
+	for range 50 {
+		again := encodeWith(c, reflect.ValueOf(m))
+		if !reflect.DeepEqual(first, again) {
+			t.Fatal("map encoding is not deterministic across runs")
+		}
+	}
+}
+
+func mustPanic(t *testing.T, want string, f func()) {
+	t.Helper()
+	defer func() {
+		r := recover()
+		if r == nil {
+			t.Fatalf("expected a panic mentioning %q", want)
+		}
+		if msg := fmt.Sprint(r); !strings.Contains(msg, want) {
+			t.Fatalf("panic %q does not mention %q", msg, want)
+		}
+	}()
+	f()
+}
+
+// mustInvalidCompile asserts that compiling rt marks the codec invalid with a
+// reason mentioning want. Unsupported types are no longer registration panics:
+// the codec is flagged and the problem is reported (attributed to the agent
+// that uses it) at discovery.
+func mustInvalidCompile(t *testing.T, want string, rt reflect.Type) {
+	t.Helper()
+	if c := defs.compile(rt); !strings.Contains(c.invalid, want) {
+		t.Fatalf("compile(%s).invalid = %q, want substring %q", rt, c.invalid, want)
+	}
+}
+
+func TestUnsupportedTypesAreRejectedAtRegistration(t *testing.T) {
+	// Flagged at compile time, reported at discovery — not invocation-time surprises.
+	mustInvalidCompile(t, "platform-dependent width", reflect.TypeFor[int]())
+	mustInvalidCompile(t, "platform-dependent width", reflect.TypeFor[uint]())
+	mustInvalidCompile(t, "not a primitive", reflect.TypeFor[map[Money]string]())
+	mustInvalidCompile(t, "unsupported type", reflect.TypeFor[chan int]())
+}
+
+func TestMalformedInputIsAnErrorNotAPanic(t *testing.T) {
+	// A string where a record is expected, and a truncated tree.
+	c := defs.compile(reflect.TypeFor[Money]())
+	tree := types.SchemaValueTree{
+		ValueNodes: []types.SchemaValueNode{types.MakeSchemaValueNodeStringValue("nope")},
+		Root:       0,
+	}
+	out := reflect.New(reflect.TypeFor[Money]()).Elem()
+	d := decoder{nodes: tree.ValueNodes}
+	if err := c.decode(&d, out, tree.Root); err == nil {
+		t.Fatal("expected an error decoding a string into a record")
+	}
+
+	empty := decoder{nodes: nil}
+	if err := c.decode(&empty, out, 0); err == nil {
+		t.Fatal("expected an error for an out-of-range node index")
+	}
+}
+
+// TestNilSliceDecodesAsEmptySlice — A nil slice and an empty slice are both an empty list on the wire, so decoding
+// normalizes nil to empty. Unlike encoding/json — which emits null for a nil
+// slice and [] for an empty one — there is no ambiguity here: []T is ALWAYS
+// list-type and never option, so "absent" is simply not representable. Spell the
+// optional list *[]T if the distinction matters.
+func TestNilSliceDecodesAsEmptySlice(t *testing.T) {
+	got := roundTrip(t, Tree{Label: "leaf", Children: nil})
+	if got.Children == nil {
+		t.Fatal("expected a non-nil empty slice after decoding")
+	}
+	if len(got.Children) != 0 {
+		t.Fatalf("expected an empty slice, got %d element(s)", len(got.Children))
+	}
+	// A nil map normalizes the same way.
+	type withMap struct{ M map[string]int64 }
+	if m := roundTrip(t, withMap{M: nil}); m.M == nil || len(m.M) != 0 {
+		t.Fatalf("expected a non-nil empty map, got %#v", m.M)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// variants and enums
+// ---------------------------------------------------------------------------
+
+// PaymentMethod — A closed sum type: the unexported marker method means no type outside this
+// package can join the variant.
+type PaymentMethod interface{ isPaymentMethod() }
+
+type Card struct {
+	Number string
+	Expiry Status
+}
+type Cash struct{}
+type Transfer struct{ IBAN string }
+
+func (Card) isPaymentMethod()     {}
+func (Cash) isPaymentMethod()     {}
+func (Transfer) isPaymentMethod() {}
+
+type Status int32
+
+const (
+	StatusActive Status = iota
+	StatusExpired
+	StatusRevoked
+)
+
+var _ = DefineEnum[Status]("active", "expired", "revoked")
+
+var _ = DefineVariant[PaymentMethod](
+	Case[Card]("card"),
+	Case[Cash]("cash"),
+	Case[Transfer]("transfer"),
+)
+
+func TestRoundTripVariantAndEnum(t *testing.T) {
+	assertRoundTrip(t, "enum", StatusExpired)
+	assertRoundTrip(t, "variant (card)", PaymentMethod(Card{Number: "4242", Expiry: StatusActive}))
+	assertRoundTrip(t, "variant (empty case)", PaymentMethod(Cash{}))
+	assertRoundTrip(t, "variant (transfer)", PaymentMethod(Transfer{IBAN: "DE00"}))
+
+	// Variants compose with everything else, which is the point of the codec design.
+	assertRoundTrip(t, "option<variant>", Some(PaymentMethod(Cash{})))
+	assertRoundTrip(t, "none of variant", None[PaymentMethod]())
+	assertRoundTrip(t, "list<variant>", []PaymentMethod{
+		Card{Number: "1", Expiry: StatusRevoked}, Cash{}, Transfer{IBAN: "X"},
+	})
+	assertRoundTrip(t, "result<variant, enum>",
+		Ok[PaymentMethod, Status](Card{Number: "9", Expiry: StatusActive}))
+	assertRoundTrip(t, "err arm carrying an enum",
+		Err[PaymentMethod, Status](StatusRevoked))
+	assertRoundTrip(t, "map<string, variant>", map[string]PaymentMethod{
+		"a": Cash{}, "b": Transfer{IBAN: "Y"},
+	})
+}
+
+func TestVariantSchemaNamesCasesInDeclarationOrder(t *testing.T) {
+	g := graphBuilder{d: defs}
+	root := g.node(defs.compile(reflect.TypeFor[PaymentMethod]()))
+	graph := g.build()
+
+	body := graph.TypeNodes[root].Body
+	if body.Tag() != types.SchemaTypeBodyVariantType {
+		t.Fatalf("expected a variant-type node, got tag %d", body.Tag())
+	}
+	var names []string
+	for _, c := range body.VariantType() {
+		names = append(names, c.Name)
+	}
+	want := []string{"card", "cash", "transfer"}
+	if !reflect.DeepEqual(names, want) {
+		t.Fatalf("variant cases = %v, want %v", names, want)
+	}
+}
+
+func TestEnumSchemaCarriesTheDeclaredNames(t *testing.T) {
+	g := graphBuilder{d: defs}
+	root := g.node(defs.compile(reflect.TypeFor[Status]()))
+	graph := g.build()
+
+	body := graph.TypeNodes[root].Body
+	if body.Tag() != types.SchemaTypeBodyEnumType {
+		t.Fatalf("expected an enum-type node, got tag %d", body.Tag())
+	}
+	if want := []string{"active", "expired", "revoked"}; !reflect.DeepEqual(body.EnumType(), want) {
+		t.Fatalf("enum names = %v, want %v", body.EnumType(), want)
+	}
+}
+
+func TestVariantAndEnumMisuseIsRejected(t *testing.T) {
+	// An interface that was never declared as a variant: flagged at compile time.
+	type Unregistered interface{ marker() }
+	mustInvalidCompile(t, "not a registered variant", reflect.TypeFor[Unregistered]())
+
+	// A value outside the declared enum range must not be silently truncated —
+	// this is an encode-time (invocation) failure, still a panic (recovered into
+	// an agent-error by the dispatcher).
+	c := defs.compile(reflect.TypeFor[Status]())
+	mustPanic(t, "outside the declared enum range", func() {
+		encodeWith(c, reflect.ValueOf(Status(99)))
+	})
+
+	// A nil interface holds no case — also encode-time.
+	vc := defs.compile(reflect.TypeFor[PaymentMethod]())
+	mustPanic(t, "must hold one of its cases", func() {
+		encodeWith(vc, reflect.ValueOf(&[]PaymentMethod{nil}[0]).Elem())
+	})
+
+	// Declaration-time validation: recorded, not panicked.
+	withDefs(t, func(d *definitions) {
+		defineVariantInto[Money](d)
+		defineEnumInto[string](d, "a")
+		mustDefErr(t, d, "requires an interface type")
+		mustDefErr(t, d, "requires a named integer type")
+	})
+}
+
+// dupVar1 — Fixtures for the variant/enum registration-error cases below.
+type dupVar1 interface{ dv1() }
+type dupVar2 interface{ dv2() }
+type dupImpl struct{}
+
+func (dupImpl) dv2() {}
+
+type dupVar3 interface{ dv3() }
+type dupImpl3 struct{}
+
+func (dupImpl3) dv3() {}
+
+type emptyVar interface{ ev() }
+type emptyEnum int32
+type dupEnum int32
+
+func TestVariantEnumRegistrationErrorsAreRecorded(t *testing.T) {
+	withDefs(t, func(d *definitions) {
+		// Re-registering an already-declared variant/enum (each on a distinct
+		// interface/type so it is a clean register-then-redefine).
+		defineVariantInto[dupVar2](d, Case[dupImpl]("a"))
+		defineVariantInto[dupVar2](d, Case[dupImpl]("b"))
+		defineEnumInto[dupEnum](d, "a")
+		defineEnumInto[dupEnum](d, "b")
+		mustDefErr(t, d, "already defined")
+		// Empty case / name lists.
+		defineVariantInto[emptyVar](d)
+		defineEnumInto[emptyEnum](d)
+		mustDefErr(t, d, "at least one case")
+		mustDefErr(t, d, "at least one name")
+		// A case that does not implement the interface, and a duplicate case name.
+		defineVariantInto[dupVar1](d, Case[Money]("m"))
+		defineVariantInto[dupVar3](d, Case[dupImpl3]("x"), Case[dupImpl3]("x"))
+		mustDefErr(t, d, "does not implement")
+		mustDefErr(t, d, "duplicate case name")
+	})
+}
+
+// TestDecodedVariantSatisfiesItsInterface — A decoded variant must be usable through its interface, not just structurally
+// equal — the decoder sets a concrete type into the interface slot.
+func TestDecodedVariantSatisfiesItsInterface(t *testing.T) {
+	got := roundTrip(t, PaymentMethod(Transfer{IBAN: "NL01"}))
+	tr, ok := got.(Transfer)
+	if !ok {
+		t.Fatalf("decoded value is %T, want Transfer", got)
+	}
+	if tr.IBAN != "NL01" {
+		t.Fatalf("IBAN = %q", tr.IBAN)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// markers, time and secrets
+// ---------------------------------------------------------------------------
+
+func TestRoundTripMarkersAndTimeTypes(t *testing.T) {
+	assertRoundTrip(t, "char", Char('é'))
+	assertRoundTrip(t, "url", URL("https://golem.cloud/agents"))
+	assertRoundTrip(t, "duration", 90*time.Second)
+	assertRoundTrip(t, "datetime", time.Unix(1_700_000_000, 123_456_789).UTC())
+
+	// and they compose like everything else
+	assertRoundTrip(t, "option<datetime>", Some(time.Unix(42, 0).UTC()))
+	assertRoundTrip(t, "list<url>", []URL{"https://a.example", "https://b.example"})
+}
+
+func TestMarkersLowerToTheirOwnWitTypes(t *testing.T) {
+	// Char is an int32 and URL is a string underneath, so without recognition by
+	// named type they would silently lower to s32 and string.
+	for _, tc := range []struct {
+		name string
+		rt   reflect.Type
+		want uint8
+	}{
+		{"Char", reflect.TypeFor[Char](), types.SchemaTypeBodyCharType},
+		{"URL", reflect.TypeFor[URL](), types.SchemaTypeBodyUrlType},
+		{"time.Time", reflect.TypeFor[time.Time](), types.SchemaTypeBodyDatetimeType},
+		{"time.Duration", reflect.TypeFor[time.Duration](), types.SchemaTypeBodyDurationType},
+	} {
+		g := graphBuilder{d: defs}
+		root := g.node(defs.compile(tc.rt))
+		if got := g.build().TypeNodes[root].Body.Tag(); got != tc.want {
+			t.Errorf("%s lowered to tag %d, want %d", tc.name, got, tc.want)
+		}
+	}
+}
+
+// TestSecretIsConfigOnly — Secret[T] lowers to a secret(inner) schema node (for
+// config declarations), is guarded against being used as a plaintext wire value
+// (it is config-only), and never leaks its payload through formatting.
+func TestSecretIsConfigOnly(t *testing.T) {
+	// Schema side: Secret[string] lowers to a secret(inner) type node — needed for
+	// the config graph and the config-metadata declaration.
+	g := graphBuilder{d: defs}
+	root := g.node(defs.compile(reflect.TypeFor[Secret[string]]()))
+	if tag := g.build().TypeNodes[root].Body.Tag(); tag != types.SchemaTypeBodySecretType {
+		t.Fatalf("Secret lowered to tag %d, want secret-type", tag)
+	}
+
+	// Value side is guarded: encoding a Secret as a wire value (e.g. as a method
+	// parameter) panics rather than shipping plaintext.
+	c := defs.compile(reflect.TypeFor[Secret[string]]())
+	func() {
+		defer func() {
+			if r := recover(); r == nil {
+				t.Fatal("encoding a Secret as a wire value should panic (config-only)")
+			}
+		}()
+		var s Secret[string]
+		encodeWith(c, reflect.ValueOf(&s).Elem())
+	}()
+
+	// Redaction: formatting must not leak the payload. %v/%s route through String,
+	// %#v through GoString.
+	s := Secret[string]{read: func() (string, error) { return "hunter2", nil }}
+	for _, out := range []string{fmt.Sprintf("%v", s), fmt.Sprintf("%#v", s)} {
+		if strings.Contains(out, "hunter2") {
+			t.Fatalf("secret leaked through formatting: %s", out)
+		}
+	}
+}
+
+// TestNilContainersAreNeverOptional — Containers must never be modelled as optional: absence is only expressible
+// through a pointer or Option[T], so there is no nil-vs-empty ambiguity.
+func TestNilContainersAreNeverOptional(t *testing.T) {
+	tagOf := func(rt reflect.Type) uint8 {
+		g := graphBuilder{d: defs}
+		root := g.node(defs.compile(rt))
+		return g.build().TypeNodes[root].Body.Tag()
+	}
+	for _, tc := range []struct {
+		name string
+		rt   reflect.Type
+		want uint8
+	}{
+		{"[]string", reflect.TypeFor[[]string](), types.SchemaTypeBodyListType},
+		{"[]byte", reflect.TypeFor[[]byte](), types.SchemaTypeBodyListType},
+		{"map[string]int64", reflect.TypeFor[map[string]int64](), types.SchemaTypeBodyMapType},
+		{"[2]int64", reflect.TypeFor[[2]int64](), types.SchemaTypeBodyFixedListType},
+		{"*[]string", reflect.TypeFor[*[]string](), types.SchemaTypeBodyOptionType},
+	} {
+		if got := tagOf(tc.rt); got != tc.want {
+			t.Errorf("%s lowered to tag %d, want %d", tc.name, got, tc.want)
+		}
+	}
+
+	// A nil slice encodes as an EMPTY LIST, never as none.
+	var nilSlice []string
+	tree := encodeWith(defs.compile(reflect.TypeFor[[]string]()), reflect.ValueOf(&nilSlice).Elem())
+	if n := tree.ValueNodes[tree.Root]; n.Tag() != types.SchemaValueNodeListValue || len(n.ListValue()) != 0 {
+		t.Fatalf("nil slice encoded as tag %d", n.Tag())
+	}
+	var nilMap map[string]int64
+	mt := encodeWith(defs.compile(reflect.TypeFor[map[string]int64]()), reflect.ValueOf(&nilMap).Elem())
+	if n := mt.ValueNodes[mt.Root]; n.Tag() != types.SchemaValueNodeMapValue || len(n.MapValue()) != 0 {
+		t.Fatalf("nil map encoded as tag %d", n.Tag())
+	}
+
+	// Only *[]T distinguishes absent from empty.
+	pc := defs.compile(reflect.TypeFor[*[]string]())
+	var absent *[]string
+	if tr := encodeWith(pc, reflect.ValueOf(&absent).Elem()); !tr.ValueNodes[tr.Root].OptionValue().IsNone() {
+		t.Fatal("a nil *[]string must encode as none")
+	}
+	empty := []string{}
+	present := &empty
+	if tr := encodeWith(pc, reflect.ValueOf(&present).Elem()); tr.ValueNodes[tr.Root].OptionValue().IsNone() {
+		t.Fatal("a pointer to an empty slice must encode as some(empty list)")
+	}
+}
+
+// pinnedNode — A pinned type-id (via NameType) overrides the derived pkg.path.TypeName in a
+// recursive type's published schema-type-def, for cross-language interop.
+type pinnedNode struct {
+	Label string
+	Next  *pinnedNode
+}
+
+var _ = NameType[pinnedNode]("myapp.custom.node")
+
+func TestNameTypePinsTheDefID(t *testing.T) {
+	g := graphBuilder{d: defs}
+	root := g.node(defs.compile(reflect.TypeFor[pinnedNode]()))
+	graph := g.build()
+
+	if graph.TypeNodes[root].Body.Tag() != types.SchemaTypeBodyRefType {
+		t.Fatal("recursive type should publish as a ref-type")
+	}
+	if len(graph.Defs) != 1 {
+		t.Fatalf("expected 1 def, got %d", len(graph.Defs))
+	}
+	if got := graph.Defs[0].Id; got != "myapp.custom.node" {
+		t.Fatalf("def id = %q, want the pinned %q", got, "myapp.custom.node")
+	}
+}
+
+func TestNameTypeRejectsConflicts(t *testing.T) {
+	type a struct{}
+	type b struct{}
+	withDefs(t, func(d *definitions) {
+		nameTypeInto[a](d, "dup.id.one")
+		// same type, same id → idempotent (records nothing)
+		before := len(d.errs)
+		nameTypeInto[a](d, "dup.id.one")
+		if len(d.errs) != before {
+			t.Fatalf("idempotent NameType recorded an error: %v", d.errs[before:])
+		}
+		nameTypeInto[a](d, "dup.id.two") // retag same type
+		nameTypeInto[b](d, "dup.id.one") // reuse id
+		nameTypeInto[struct{ X int }](d, "")
+		mustDefErr(t, d, "already pinned")
+		mustDefErr(t, d, "non-empty")
+	})
+}
diff --git a/sdks/go/golem/compile_fail_test.go b/sdks/go/golem/compile_fail_test.go
new file mode 100644
index 0000000000..6ef69fd194
--- /dev/null
+++ b/sdks/go/golem/compile_fail_test.go
@@ -0,0 +1,49 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem_test
+
+import (
+	"os"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+// TestWrongAgentClientIsACompileError — The cross-agent type-safety guarantee is only useful if it actually fails to
+// compile. This drives `go build` over a testdata program that Calls a
+// PaymentID method with an OrderID client and asserts the type-checker rejects
+// it — turning "it's a compile error" from a comment into a test.
+func TestWrongAgentClientIsACompileError(t *testing.T) {
+	goBin, err := exec.LookPath("go")
+	if err != nil {
+		t.Skip("go toolchain not on PATH; skipping compile-failure check")
+	}
+
+	cmd := exec.Command(goBin, "build", "-o", os.DevNull, "./testdata/wrong_client.go")
+	out, err := cmd.CombinedOutput()
+
+	if err == nil {
+		t.Fatalf("expected ./testdata/wrong_client.go to fail compilation, but it built successfully")
+	}
+
+	msg := string(out)
+	// The error must be the client-type mismatch, not some unrelated failure
+	// (e.g. a link error would name a relocation, not these types).
+	for _, want := range []string{"Client[OrderID]", "Client[PaymentID]", "Charge.Call"} {
+		if !strings.Contains(msg, want) {
+			t.Fatalf("compile error did not mention %q; got:\n%s", want, msg)
+		}
+	}
+}
diff --git a/sdks/go/golem/componentize-go.toml b/sdks/go/golem/componentize-go.toml
new file mode 100644
index 0000000000..8d196aaf06
--- /dev/null
+++ b/sdks/go/golem/componentize-go.toml
@@ -0,0 +1,5 @@
+# Consumed by `componentize-go` in downstream agent projects: because this file
+# ships with the SDK module, an agent only needs to run `componentize-go build`
+# with no WIT flags.
+worlds = ["golem:agent-guest/agent-guest"]
+wit_paths = ["wit"]
diff --git a/sdks/go/golem/config.go b/sdks/go/golem/config.go
new file mode 100644
index 0000000000..d924357ef2
--- /dev/null
+++ b/sdks/go/golem/config.go
@@ -0,0 +1,501 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"fmt"
+	"reflect"
+
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+	host "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_host"
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	reveal "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_secrets_reveal"
+	secrets "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_secrets_types"
+)
+
+// Config and secrets.
+//
+// Config is attached to an agent as a single struct type and read only from
+// within that agent's own execution — its methods and its constructor — for that
+// agent's config type. This mirrors the TS SDK (config is instance-bound); there
+// are no free-floating, read-from-anywhere descriptors.
+//
+// Declare the config struct and attach it to the agent with
+// [DefineConfiguredAgent]; the config type Cfg rides on the returned [Agent], so
+// there is no separate config handle:
+//
+//	type ShopConfig struct {
+//	    Greeting string
+//	    APIKey   golem.Secret[string] // a secret field, at any depth
+//	}
+//	var Shop = golem.DefineConfiguredAgent[ShopId, ShopState, ShopConfig](spec, initShop)
+//
+// and read it from inside a method via [Agent.Config] (or, in the constructor,
+// [InitContext.Config]):
+//
+//	cfg := Shop.Config(ctx)  // ctx is the running agent's *Context[S]
+//	_ = cfg.Greeting         // local field — cached (worker-lifetime), so this is fast
+//	_ = cfg.APIKey.Get()     // secret field — re-reads the host each call (live)
+//
+// Config is materialized ONCE per worker and cached, so calling Shop.Config(ctx)
+// on a hot method is near-free: local fields are read from the host on the first
+// call and reused for the worker's life. Only **secret** fields stay live — a
+// [Secret] field is a lazy handle whose [Secret.Get] re-reads the host on every
+// call, so a *rotated* secret is observed and the user decides when to read (and
+// whether to store) it.
+//
+// Each exported field of the config struct becomes a config key; nested structs
+// flatten into multi-segment paths (field names lower-cased to match
+// record-field naming), and any [Secret]-typed field becomes a secret. The
+// platform provisions the values (golem.yaml config/env/envDefaults/
+// secretDefaults + the CLI); the guest reads them at runtime through
+// golem:agent/host.get-config-value, keyed by the multi-segment path. Access is
+// gated by these declarations: reading an *undeclared* key traps, as does an
+// unset required key — declare a field's type as a pointer to read it back as
+// nil instead.
+//
+// The wire type-name distinction between a plain value and a secret is the schema
+// node: a secret's value type is secret(inner). A secret read returns an opaque
+// handle that must be revealed through golem:secrets/reveal.
+
+// configDecl is one registered config/secret key on an agent. For a secret, typ
+// is Secret[T] so the schema graph carries a secret(inner) node; for local
+// config it is the value type directly.
+type configDecl struct {
+	source common.AgentConfigSource
+	path   []string
+	typ    reflect.Type
+}
+
+// NoConfig is the empty config type used by an agent that declares no config. It
+// has no fields, so it flattens to zero config declarations. [DefineAgent] uses
+// it internally; config-less agents never name it.
+type NoConfig struct{}
+
+
+func configKind(source common.AgentConfigSource) string {
+	if source == common.AgentConfigSourceSecret {
+		return "secret"
+	}
+	return "config"
+}
+
+// recordConfigOn validates a single declaration against an already-resolved
+// entry and records it. Shared by every declaration path (the flattened config
+// struct).
+func recordConfigOn(d *definitions, e *agentEntry, agentName string, source common.AgentConfigSource, path []string, typ reflect.Type) {
+	kind := configKind(source)
+	if len(path) == 0 {
+		d.recordErr(agentName, "", "%s: declared with an empty path", kind)
+		return
+	}
+	for _, seg := range path {
+		if seg == "" {
+			d.recordErr(agentName, "", "%s %v: path has an empty segment", kind, path)
+			return
+		}
+	}
+	for _, cd := range e.configs {
+		if pathsEqual(cd.path, path) {
+			d.recordErr(agentName, "", "config path %v declared more than once", path)
+			return
+		}
+	}
+	e.configs = append(e.configs, configDecl{source: source, path: clonePath(path), typ: typ})
+}
+
+// ---------------------------------------------------------------------------
+// struct/record flattening: an agent's whole config surface is one Go struct.
+// configLeaves flattens it into per-key declarations, and materializeConfig
+// reads it back into a struct value.
+// ---------------------------------------------------------------------------
+
+// configLeaf is one flattened config key discovered in a struct: its source,
+// wire path, Go type, and the field-index path to set it during materialize.
+type configLeaf struct {
+	source common.AgentConfigSource
+	path   []string
+	typ    reflect.Type
+	index  []int
+}
+
+var secretishType = reflect.TypeOf((*secretish)(nil)).Elem()
+
+// isSecretType reports whether t is a golem.Secret[...] (the only type that
+// implements the unexported secret interface), which flattens as a secret leaf.
+func isSecretType(t reflect.Type) bool { return t.Implements(secretishType) }
+
+// configLeaves flattens a config struct into its leaves. A Secret field is a
+// secret leaf; a plain (non-secret) struct field recurses; everything else is a
+// local leaf. Pure — shared by declaration (flattenConfigStruct) and read
+// (materializeConfig).
+func configLeaves(cfgType reflect.Type) ([]configLeaf, error) {
+	if cfgType.Kind() != reflect.Struct {
+		return nil, fmt.Errorf("config type must be a struct, got %s", cfgType)
+	}
+	var leaves []configLeaf
+	var walk func(prefix []string, idx []int, t reflect.Type)
+	walk = func(prefix []string, idx []int, t reflect.Type) {
+		for i := 0; i < t.NumField(); i++ {
+			f := t.Field(i)
+			if !f.IsExported() {
+				continue
+			}
+			path := append(clonePath(prefix), lowerFirst(f.Name))
+			index := append(append([]int(nil), idx...), i)
+			switch {
+			case isSecretType(f.Type):
+				leaves = append(leaves, configLeaf{common.AgentConfigSourceSecret, path, f.Type, index})
+			case f.Type.Kind() == reflect.Struct:
+				walk(path, index, f.Type)
+			default:
+				leaves = append(leaves, configLeaf{common.AgentConfigSourceLocal, path, f.Type, index})
+			}
+		}
+	}
+	walk(nil, nil, cfgType)
+	return leaves, nil
+}
+
+// flattenConfigStruct records every leaf of a config struct on the entry. The
+// empty [NoConfig] struct yields no leaves and records nothing.
+func flattenConfigStruct(d *definitions, e *agentEntry, agentName string, cfgType reflect.Type) {
+	leaves, err := configLeaves(cfgType)
+	if err != nil {
+		d.recordErr(agentName, "", "config: %v", err)
+		return
+	}
+	for _, lf := range leaves {
+		recordConfigOn(d, e, agentName, lf.source, lf.path, lf.typ)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// runtime reads — the host calls are wasm-only; the graph build and decode are
+// pure and covered by native tests.
+// ---------------------------------------------------------------------------
+
+// Config returns the agent's config from within a method. scope is the running
+// agent's *[Context]: because it carries the agent's own state type S — and the
+// method returns the agent's own Cfg — config can be read only from within the
+// owning agent's method (no free-floating read).
+//
+// The config is materialized ONCE per worker and cached (see [instance.config]),
+// so repeated calls on a hot method are near-free: its local fields are read from
+// the host on the first call and reused for the worker's life. Only its **secret**
+// fields stay live — a [Secret] field is a lazy handle whose [Secret.Get] re-reads
+// the host each call, so a rotated secret is observed and the user decides when to
+// read (and whether to store) it. A config read failing is a hard failure with no
+// in-band recovery, so — like the TS/Rust/Scala SDKs — Config fails loud: the
+// panic is recovered by the invoke dispatcher into an agent-error.
+func (a *Agent[Id, S, Cfg]) Config(scope agentScope[S]) Cfg {
+	// scope is a compile-time gate only: requiring it means the read can happen
+	// only from inside the agent's own execution.
+	_ = scope
+	return materializeAgentConfig[Cfg]()
+}
+
+// Config reads the agent's config from within its constructor (fail-loud, like
+// [Agent.Config], and populating the same per-worker cache the methods reuse). It
+// reads config off its own context rather than the agent because naming the agent
+// in its own package-level initializer would be a self-reference.
+func (c *InitContext[Id, S, Cfg]) Config() Cfg {
+	return materializeAgentConfig[Cfg]()
+}
+
+// cachedAgentConfig returns the worker's already-materialized config, if any. It
+// is the pure cache-hit fast path — no host call — so it is safe to reference
+// from native tests (the host-backed miss path lives in materializeAgentConfig,
+// reachable only from the wasm Config methods above).
+func cachedAgentConfig[Cfg any]() (Cfg, bool) {
+	if active != nil && active.config != nil {
+		return active.config.(Cfg), true
+	}
+	var zero Cfg
+	return zero, false
+}
+
+// materializeAgentConfig returns the agent's config, materializing it once per
+// worker and caching it on the running instance. On the first call it reads the
+// local leaves from the host (secret leaves become lazy handles) and stores the
+// Cfg; later calls return the cache. Host-backed on the miss path.
+func materializeAgentConfig[Cfg any]() Cfg {
+	if cfg, ok := cachedAgentConfig[Cfg](); ok {
+		return cfg
+	}
+	cfg, err := materializeConfig[Cfg](func(lf configLeaf) (reflect.Value, error) {
+		return readConfigLeaf(defs, lf)
+	})
+	if err != nil {
+		panic(err)
+	}
+	if active != nil {
+		active.config = cfg
+	}
+	return cfg
+}
+
+// materializeConfig assembles a Cfg value by reading each declared leaf through
+// readLeaf. Pure given readLeaf — [Agent.Config] / [InitContext.Config] supply
+// the host-backed reader, tests supply a fake.
+func materializeConfig[Cfg any](readLeaf func(lf configLeaf) (reflect.Value, error)) (Cfg, error) {
+	var zero Cfg
+	cfgType := reflect.TypeFor[Cfg]()
+	leaves, err := configLeaves(cfgType)
+	if err != nil {
+		return zero, err
+	}
+	out := reflect.New(cfgType).Elem()
+	for _, lf := range leaves {
+		v, err := readLeaf(lf)
+		if err != nil {
+			return zero, err
+		}
+		out.FieldByIndex(lf.index).Set(v)
+	}
+	return out.Interface().(Cfg), nil
+}
+
+// readConfigLeaf reads one leaf from the host: a local value is decoded directly;
+// a secret is fetched, revealed, and rebuilt as a Secret[T].
+func readConfigLeaf(d *definitions, lf configLeaf) (reflect.Value, error) {
+	if lf.source == common.AgentConfigSourceSecret {
+		return readSecretLeaf(lf)
+	}
+	tree := host.GetConfigValue(lf.path, d.graphForType(lf.typ))
+	dst := reflect.New(lf.typ).Elem()
+	dec := decoder{nodes: tree.ValueNodes}
+	if err := d.compile(lf.typ).decode(&dec, dst, tree.Root); err != nil {
+		return reflect.Value{}, fmt.Errorf("golem/config %v: %w", lf.path, err)
+	}
+	return dst, nil
+}
+
+// readSecretLeaf builds the Secret[T] handle for a config secret leaf. It does
+// NOT touch the host here: the handle re-reads the current value lazily on each
+// [Secret.Get], so a rotated secret is observed. The bind is done by reflection
+// because the inner T is not statically known at this point. Keeping the host
+// call out of this path (it lives in the Secret's closure, reachable only from a
+// user's Secret.Get) is what lets native tests link.
+func readSecretLeaf(lf configLeaf) (reflect.Value, error) {
+	ptr := reflect.New(lf.typ) // *Secret[T]
+	ptr.Interface().(secretBinder).secretBindPath(clonePath(lf.path))
+	return ptr.Elem(), nil
+}
+
+// readSecretValue fetches, reveals, and decodes a config secret's CURRENT value.
+// [Secret.Get] calls it on every access, so each read returns the latest value
+// (a fresh get-config-value mints a handle pinned to the current revision, which
+// reveal then unpacks). Host-backed — reachable only from Secret.Get, never from
+// the config-materialization path.
+func readSecretValue[T any](d *definitions, path []string) (T, error) {
+	var zero T
+	innerType := reflect.TypeFor[T]()
+
+	handleTree := host.GetConfigValue(path, d.graphForType(reflect.TypeFor[Secret[T]]()))
+	handle, err := extractSecretHandle(path, handleTree)
+	if err != nil {
+		return zero, err
+	}
+	res := reveal.Reveal(handle, d.graphForType(innerType))
+	if res.IsErr() {
+		return zero, secretErrorToGo(path, res.Err())
+	}
+
+	dst := reflect.New(innerType).Elem()
+	dec := decoder{nodes: res.Ok().ValueNodes}
+	if err := d.compile(innerType).decode(&dec, dst, res.Ok().Root); err != nil {
+		return zero, fmt.Errorf("golem/secret %v: %w", path, err)
+	}
+	return dst.Interface().(T), nil
+}
+
+// buildConfigDecls derives the agent-type config metadata, compiling each key's
+// value type into the shared graph g (so ValueType is an index into the agent's
+// schema). An uncompilable type lands in g.invalids and is attributed by
+// discover, exactly like a method parameter.
+func (d *definitions) buildConfigDecls(g *graphBuilder, cds []configDecl) []common.AgentConfigDeclaration {
+	if len(cds) == 0 {
+		return nil
+	}
+	out := make([]common.AgentConfigDeclaration, 0, len(cds))
+	for _, cd := range cds {
+		out = append(out, common.AgentConfigDeclaration{
+			Source:    cd.source,
+			Path:      cd.path,
+			ValueType: g.node(d.compile(cd.typ)),
+		})
+	}
+	return out
+}
+
+// graphForType builds a standalone schema graph whose root is typ — the shape
+// get-config-value and reveal expect for "expected".
+func (d *definitions) graphForType(typ reflect.Type) types.SchemaGraph {
+	g := graphBuilder{d: d}
+	root := g.node(d.compile(typ))
+	graph := g.build()
+	graph.Root = root
+	return graph
+}
+
+// decodeConfigValue decodes a config value tree into T through T's codec. Pure.
+func decodeConfigValue[T any](d *definitions, path []string, tree types.SchemaValueTree) (T, error) {
+	var zero T
+	typ := reflect.TypeFor[T]()
+	dst := reflect.New(typ).Elem()
+	dec := decoder{nodes: tree.ValueNodes}
+	if err := d.compile(typ).decode(&dec, dst, tree.Root); err != nil {
+		return zero, fmt.Errorf("golem/config %v: %w", path, err)
+	}
+	return dst.Interface().(T), nil
+}
+
+// extractSecretHandle pulls the secret handle out of a get-config-value result.
+// Pure — the value tree carries the handle at its root as a secret value node.
+func extractSecretHandle(path []string, tree types.SchemaValueTree) (*types.Secret, error) {
+	if tree.Root < 0 || int(tree.Root) >= len(tree.ValueNodes) {
+		return nil, fmt.Errorf("golem/secret %v: empty config value tree", path)
+	}
+	node := tree.ValueNodes[tree.Root]
+	if node.Tag() != types.SchemaValueNodeSecretValue {
+		return nil, fmt.Errorf("golem/secret %v: expected a secret value, got node tag %d", path, node.Tag())
+	}
+	return node.SecretValue(), nil
+}
+
+// secretErrorToGo maps a host secret-error onto a Go error, keeping the case
+// distinguishable rather than flattening it to a bare string.
+func secretErrorToGo(path []string, e secrets.SecretError) error {
+	switch e.Tag() {
+	case secrets.SecretErrorUnavailable:
+		return fmt.Errorf("golem/secret %v: unavailable: %s", path, e.Unavailable())
+	case secrets.SecretErrorVersionNotFound:
+		return fmt.Errorf("golem/secret %v: requested version not found", path)
+	case secrets.SecretErrorInternal:
+		return fmt.Errorf("golem/secret %v: internal error: %s", path, e.Internal())
+	default:
+		return fmt.Errorf("golem/secret %v: secret error (tag %d)", path, e.Tag())
+	}
+}
+
+// ---------------------------------------------------------------------------
+// config-on-RPC: a caller can override a callee's local config values at client
+// creation. The values are encoded here (pure) and threaded into make-wasm-rpc
+// by ClientFor.
+// ---------------------------------------------------------------------------
+
+// configOverrideFn produces the config overrides for one WithConfig option,
+// deferred so the values are encoded against the definition set at
+// client-creation time.
+type configOverrideFn func(d *definitions) ([]common.TypedAgentConfigValue, error)
+
+// WithConfig supplies the callee's local config values at client creation
+// (make-wasm-rpc's agent-config), overriding what the platform would otherwise
+// provision. Cfg is inferred from value; each local field is encoded as an
+// override and validated against the target agent's declarations by [ClientFor]
+// (which already names the target). Secret fields are provisioned by the
+// platform, not by a caller, so they are skipped.
+func WithConfig[Cfg any](value Cfg) ClientOpt {
+	return func(o *clientOpts) {
+		o.configs = append(o.configs, func(d *definitions) ([]common.TypedAgentConfigValue, error) {
+			return encodeConfigOverrides(d, value)
+		})
+	}
+}
+
+// encodeConfigOverrides encodes each local leaf of a config value into a typed
+// override. Secret leaves are platform-provisioned, so they are skipped rather
+// than sent. Pure.
+func encodeConfigOverrides[Cfg any](d *definitions, value Cfg) ([]common.TypedAgentConfigValue, error) {
+	leaves, err := configLeaves(reflect.TypeFor[Cfg]())
+	if err != nil {
+		return nil, err
+	}
+	root := reflect.ValueOf(value)
+	var out []common.TypedAgentConfigValue
+	for _, lf := range leaves {
+		if lf.source == common.AgentConfigSourceSecret {
+			continue
+		}
+		tv, err := encodeReflectValue(d, root.FieldByIndex(lf.index))
+		if err != nil {
+			return nil, fmt.Errorf("config override %v: %w", lf.path, err)
+		}
+		out = append(out, common.TypedAgentConfigValue{Path: clonePath(lf.path), Value: tv})
+	}
+	return out, nil
+}
+
+// buildAgentConfig encodes and validates the client's config overrides against
+// the target agent's declarations. Pure — the encode and the declared-key check
+// are both native-testable; ClientFor supplies the live definition set.
+func buildAgentConfig(d *definitions, e *agentEntry, overrides []configOverrideFn) ([]common.TypedAgentConfigValue, error) {
+	if len(overrides) == 0 {
+		return nil, nil
+	}
+	var out []common.TypedAgentConfigValue
+	for _, fn := range overrides {
+		tvs, err := fn(d)
+		if err != nil {
+			return nil, err
+		}
+		for _, tv := range tvs {
+			if !configDeclared(e, tv.Path) {
+				return nil, fmt.Errorf("config override %v is not a declared config key on the agent", tv.Path)
+			}
+			out = append(out, tv)
+		}
+	}
+	return out, nil
+}
+
+func configDeclared(e *agentEntry, path []string) bool {
+	for _, cd := range e.configs {
+		if pathsEqual(cd.path, path) {
+			return true
+		}
+	}
+	return false
+}
+
+// encodeReflectValue encodes a Go value (as a reflect.Value) into a typed schema
+// value (graph + value tree) for the wire. Pure.
+func encodeReflectValue(d *definitions, v reflect.Value) (tv types.TypedSchemaValue, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			err = fmt.Errorf("encoding config value: %v", r)
+		}
+	}()
+	typ := v.Type()
+	return types.TypedSchemaValue{
+		Graph: d.graphForType(typ),
+		Value: encodeWith(d.compile(typ), v),
+	}, nil
+}
+
+func pathsEqual(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func clonePath(p []string) []string { return append([]string(nil), p...) }
diff --git a/sdks/go/golem/config_test.go b/sdks/go/golem/config_test.go
new file mode 100644
index 0000000000..e94869df81
--- /dev/null
+++ b/sdks/go/golem/config_test.go
@@ -0,0 +1,318 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	secrets "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_secrets_types"
+)
+
+// Config/secret declaration and the pure read core are unit-tested here; the
+// actual get-config-value/reveal host calls are wasm-only and covered by the
+// integration layers (see the go-sdk-testing-strategy notes).
+
+type cfgId struct{ Name string }
+type cfgState struct{}
+
+// demoDBConfig / demoAppConfig is a config struct with a nested struct and a
+// secret field, exercising flattening at every position.
+type demoDBConfig struct {
+	Url      string
+	Password Secret[string]
+}
+type demoAppConfig struct {
+	Greeting string
+	Db       demoDBConfig
+}
+
+// cfgConfiguredAgent registers the "Cfg" agent with config type Cfg attached (a
+// no-op constructor — the host read must stay out of the natively-linked test).
+func cfgConfiguredAgent[Cfg any](d *definitions) *Agent[cfgId, cfgState, Cfg] {
+	return defineConfiguredAgentInto[cfgId, cfgState, Cfg](
+		d,
+		Spec{Name: "Cfg"},
+		func(*InitContext[cfgId, cfgState, Cfg]) *cfgState { return &cfgState{} },
+	)
+}
+
+// TestConfigDeclarationsInMetadata — DefineConfiguredAgent flattens the agent's
+// config struct into the agent-type metadata: local fields as local declarations,
+// the secret field carrying a secret(inner) value type.
+func TestConfigDeclarationsInMetadata(t *testing.T) {
+	withDefs(t, func(d *definitions) {
+		cfgConfiguredAgent[demoAppConfig](d)
+
+		out, errs := d.discover()
+		if len(errs) != 0 {
+			t.Fatalf("unexpected definition errors: %v", errs)
+		}
+		at := out[0]
+
+		want := map[string]common.AgentConfigSource{
+			"greeting":    common.AgentConfigSourceLocal,
+			"db/url":      common.AgentConfigSourceLocal,
+			"db/password": common.AgentConfigSourceSecret,
+		}
+		if len(at.Config) != len(want) {
+			t.Fatalf("want %d config declarations, got %d: %+v", len(want), len(at.Config), at.Config)
+		}
+		for _, dcl := range at.Config {
+			key := strings.Join(dcl.Path, "/")
+			src, ok := want[key]
+			if !ok {
+				t.Errorf("unexpected config path %q", key)
+				continue
+			}
+			if dcl.Source != src {
+				t.Errorf("%s: source = %d, want %d", key, dcl.Source, src)
+			}
+			body := at.Schema.TypeNodes[dcl.ValueType].Body
+			if src == common.AgentConfigSourceSecret && body.Tag() != types.SchemaTypeBodySecretType {
+				t.Errorf("%s: value type tag = %d, want secret(%d)", key, body.Tag(), types.SchemaTypeBodySecretType)
+			}
+			if key == "greeting" && body.Tag() != types.SchemaTypeBodyStringType {
+				t.Errorf("greeting: value type tag = %d, want string(%d)", body.Tag(), types.SchemaTypeBodyStringType)
+			}
+		}
+	})
+}
+
+func TestConfigNonStructReported(t *testing.T) {
+	withDefs(t, func(d *definitions) {
+		cfgConfiguredAgent[int](d)
+		mustDefErr(t, d, "must be a struct")
+	})
+}
+
+// TestMisuseDuplicateConfigPath — the same path must not be recorded twice on one
+// agent. (Not reachable from a single config struct — field names are unique — so
+// the defensive check in recordConfigOn is exercised directly.)
+func TestMisuseDuplicateConfigPath(t *testing.T) {
+	withDefs(t, func(d *definitions) {
+		cfgConfiguredAgent[NoConfig](d)
+		e := d.agents["Cfg"]
+		recordConfigOn(d, e, "Cfg", common.AgentConfigSourceLocal, []string{"k"}, reflect.TypeFor[string]())
+		recordConfigOn(d, e, "Cfg", common.AgentConfigSourceLocal, []string{"k"}, reflect.TypeFor[string]())
+		mustDefErr(t, d, "declared more than once")
+	})
+}
+
+// TestConfigDecodeLocalValue — decodeConfigValue decodes a get-config-value result
+// tree through the value type's codec — the pure half of a local read.
+func TestConfigDecodeLocalValue(t *testing.T) {
+	d := newDefinitions()
+	tree := types.SchemaValueTree{
+		ValueNodes: []types.SchemaValueNode{types.MakeSchemaValueNodeStringValue("hi")},
+		Root:       0,
+	}
+	got, err := decodeConfigValue[string](d, []string{"greeting"}, tree)
+	if err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if got != "hi" {
+		t.Fatalf("decoded %q, want %q", got, "hi")
+	}
+}
+
+// TestExtractSecretHandle — extractSecretHandle pulls the secret handle out of a
+// get-config-value result, and rejects a tree that is not a secret value — the
+// pure half of a secret read.
+func TestExtractSecretHandle(t *testing.T) {
+	// A real *Secret can only be built by the host (its constructor pulls in a
+	// wasmimport), so use a nil handle: this still exercises the tag dispatch and
+	// that the handle at the tree root is returned. The revealed round trip is a
+	// host concern, covered by integration.
+	var handle *types.Secret
+	tree := types.SchemaValueTree{
+		ValueNodes: []types.SchemaValueNode{types.MakeSchemaValueNodeSecretValue(handle)},
+		Root:       0,
+	}
+	got, err := extractSecretHandle([]string{"api"}, tree)
+	if err != nil {
+		t.Fatalf("extract: %v", err)
+	}
+	if got != handle {
+		t.Fatalf("extracted a different handle")
+	}
+
+	notSecret := types.SchemaValueTree{
+		ValueNodes: []types.SchemaValueNode{types.MakeSchemaValueNodeStringValue("nope")},
+		Root:       0,
+	}
+	if _, err := extractSecretHandle([]string{"api"}, notSecret); err == nil {
+		t.Fatal("expected an error extracting a non-secret value")
+	}
+}
+
+// TestMaterializeConfig — materializeConfig assembles the struct from per-leaf
+// reads — the pure half of AgentConfig.Get, tested with a fake reader (the real
+// reader hits the host).
+func TestMaterializeConfig(t *testing.T) {
+	got, err := materializeConfig[demoAppConfig](func(lf configLeaf) (reflect.Value, error) {
+		switch strings.Join(lf.path, "/") {
+		case "greeting":
+			return reflect.ValueOf("hello"), nil
+		case "db/url":
+			return reflect.ValueOf("db://x"), nil
+		case "db/password":
+			// A config secret is a handle backed by a live-read closure, not a value.
+			return reflect.ValueOf(Secret[string]{read: func() (string, error) { return "s3cr3t", nil }}), nil
+		default:
+			return reflect.Value{}, fmt.Errorf("unexpected leaf %v", lf.path)
+		}
+	})
+	if err != nil {
+		t.Fatalf("materialize: %v", err)
+	}
+	if got.Greeting != "hello" {
+		t.Errorf("Greeting = %q", got.Greeting)
+	}
+	if got.Db.Url != "db://x" {
+		t.Errorf("Db.Url = %q", got.Db.Url)
+	}
+	if pw := got.Db.Password.Get(); pw != "s3cr3t" {
+		t.Errorf("Db.Password.Get() = %q", pw)
+	}
+}
+
+// TestSecretGetIsLive — Secret.Get re-reads on every call (so a rotated secret is
+// observed, not a cached snapshot), and a zero-value Secret panics with a clear
+// message rather than a cryptic nil-closure dereference.
+func TestSecretGetIsLive(t *testing.T) {
+	n := 0
+	s := Secret[string]{read: func() (string, error) { n++; return fmt.Sprintf("v%d", n), nil }}
+	if a := s.Get(); a != "v1" {
+		t.Fatalf("first Get = %q, want v1", a)
+	}
+	if b := s.Get(); b != "v2" {
+		t.Fatalf("second Get = %q, want v2 (Get must re-read, not cache)", b)
+	}
+	func() {
+		defer func() {
+			if recover() == nil {
+				t.Fatal("zero-value Secret.Get should panic")
+			}
+		}()
+		var zero Secret[string]
+		_ = zero.Get()
+	}()
+}
+
+// TestWithConfigEncodesLocalsSkipsSecrets — WithConfig encodes each local leaf of
+// the config value as an override (validated against the target's declarations)
+// and skips the platform-provisioned secret leaf.
+func TestWithConfigEncodesLocalsSkipsSecrets(t *testing.T) {
+	withDefs(t, func(d *definitions) {
+		cfgConfiguredAgent[demoAppConfig](d)
+		noDefErrs(t, d)
+
+		var o clientOpts
+		WithConfig(demoAppConfig{
+			Greeting: "hi",
+			Db:       demoDBConfig{Url: "db://prod"},
+		})(&o)
+
+		got, err := buildAgentConfig(d, d.agents["Cfg"], o.configs)
+		if err != nil {
+			t.Fatalf("buildAgentConfig: %v", err)
+		}
+		// greeting + db/url; db/password (secret) is skipped.
+		if len(got) != 2 {
+			t.Fatalf("want 2 overrides, got %d: %+v", len(got), got)
+		}
+		byPath := map[string]types.TypedSchemaValue{}
+		for _, tv := range got {
+			byPath[strings.Join(tv.Path, "/")] = tv.Value
+		}
+		if _, ok := byPath["db/password"]; ok {
+			t.Error("secret leaf should not be sent as an override")
+		}
+		val, err := decodeConfigValue[string](d, []string{"greeting"}, byPath["greeting"].Value)
+		if err != nil {
+			t.Fatalf("decode greeting override: %v", err)
+		}
+		if val != "hi" {
+			t.Fatalf("greeting override = %q, want %q", val, "hi")
+		}
+	})
+}
+
+// TestWithConfigUndeclaredRejected — Overriding config against an agent that
+// declares none is rejected client-side (no key matches). Encodes demoAppConfig
+// overrides directly and validates them against a no-config agent's entry.
+func TestWithConfigUndeclaredRejected(t *testing.T) {
+	withDefs(t, func(d *definitions) {
+		cfgConfiguredAgent[NoConfig](d) // agent "Cfg" declares no config
+		var o clientOpts
+		o.configs = append(o.configs, func(dd *definitions) ([]common.TypedAgentConfigValue, error) {
+			return encodeConfigOverrides(dd, demoAppConfig{Greeting: "x"})
+		})
+		if _, err := buildAgentConfig(d, d.agents["Cfg"], o.configs); err == nil {
+			t.Fatal("expected an error overriding an undeclared config key")
+		}
+	})
+}
+
+// TestConfigCacheHit — once a worker's config is materialized it is cached on the
+// instance; the pure cache-hit path returns it as-is with no host read (so a hot
+// method's Config(ctx) is near-free). Misses report ok=false so the caller reads.
+func TestConfigCacheHit(t *testing.T) {
+	prev := active
+	defer func() { active = prev }()
+
+	active = nil
+	if _, ok := cachedAgentConfig[demoAppConfig](); ok {
+		t.Fatal("miss expected with no active instance")
+	}
+	active = &instance{}
+	if _, ok := cachedAgentConfig[demoAppConfig](); ok {
+		t.Fatal("miss expected before the first materialize")
+	}
+
+	active.config = demoAppConfig{Greeting: "cached", Db: demoDBConfig{Url: "db://x"}}
+	got, ok := cachedAgentConfig[demoAppConfig]()
+	if !ok {
+		t.Fatal("hit expected after caching")
+	}
+	if got.Greeting != "cached" || got.Db.Url != "db://x" {
+		t.Fatalf("cached config = %+v", got)
+	}
+}
+
+func TestSecretErrorToGo(t *testing.T) {
+	cases := []struct {
+		name string
+		in   secrets.SecretError
+		want string
+	}{
+		{"unavailable", secrets.MakeSecretErrorUnavailable("source down"), "unavailable"},
+		{"internal", secrets.MakeSecretErrorInternal("boom"), "internal error"},
+	}
+	for _, c := range cases {
+		got := secretErrorToGo([]string{"api", "key"}, c.in).Error()
+		if !strings.Contains(got, c.want) {
+			t.Errorf("%s: %q does not contain %q", c.name, got, c.want)
+		}
+		if !strings.Contains(got, "api") {
+			t.Errorf("%s: error should name the path: %q", c.name, got)
+		}
+	}
+}
diff --git a/sdks/go/golem/definition.go b/sdks/go/golem/definition.go
new file mode 100644
index 0000000000..d87754ddf4
--- /dev/null
+++ b/sdks/go/golem/definition.go
@@ -0,0 +1,212 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+)
+
+// Definition errors are problems found while registering or deriving agent
+// definitions — a bad Spec, an unsupported field type, a conflicting NameType,
+// an invalid HTTP route. They are *collected*, not panicked.
+//
+// The reason is structural: agents are declared from package-level vars, so a
+// panic fires during init() — before the host can call any export — and surfaces
+// as an opaque wasm trap with no message. Instead the SDK records every such
+// problem and reports it through the export channels that do carry an error:
+// discover-agent-types (what the CLI calls at deploy) and initialize. This is
+// the general form of the rule "anything we cannot catch at compile time must be
+// checked at runtime and reported during discovery."
+
+// definitionError is one recorded problem, attributed as precisely as the point
+// that found it allows.
+type definitionError struct {
+	agent  string // "" when not tied to a specific agent (e.g. NameType, a bad type)
+	method string // "" when not method-specific
+	detail string
+}
+
+func (e definitionError) Error() string {
+	switch {
+	case e.agent != "" && e.method != "":
+		return fmt.Sprintf("golem: agent %q method %q: %s", e.agent, e.method, e.detail)
+	case e.agent != "":
+		return fmt.Sprintf("golem: agent %q: %s", e.agent, e.detail)
+	default:
+		return "golem: " + e.detail
+	}
+}
+
+// definitions holds everything built up as agents, methods, types and pins are
+// declared. It is the explicit subject of both registration (the …Into helpers)
+// and discovery ([discover]) — so a test builds a fresh instance, registers a
+// controlled set into it, and dumps the result, with no package-global state.
+//
+// The public API (DefineAgent, …) registers into the single package-global
+// [defs]; the exports read it back. Registration runs single-goroutine at
+// package init and the host calls the exports single-threaded on this target, so
+// the maps need no locking.
+type definitions struct {
+	agents    map[string]*agentEntry
+	order     []string
+	idToAgent map[reflect.Type]string // Id type -> agent name, for ClientFor
+	variants  map[reflect.Type]*variantDef
+	enums     map[reflect.Type]*enumDef
+	pins      map[reflect.Type]string // NameType type-id overrides
+	codecs    map[reflect.Type]*codec // compile() memoization
+	errs      []definitionError       // registration-phase errors (derivation adds more)
+}
+
+func newDefinitions() *definitions {
+	return &definitions{
+		agents:    map[string]*agentEntry{},
+		idToAgent: map[reflect.Type]string{},
+		variants:  map[reflect.Type]*variantDef{},
+		enums:     map[reflect.Type]*enumDef{},
+		pins:      map[reflect.Type]string{},
+		codecs:    map[reflect.Type]*codec{},
+	}
+}
+
+// defs is the process-wide definition state the public API builds into.
+//
+// INVARIANT — keep the wrappers logic-free: the public registration functions
+// (DefineAgent, Implement, DefineVariant, DefineEnum, NameType) MUST be one-line
+// wrappers that forward to their `…Into(defs, …)` helper and nothing more. All
+// logic — validation, error recording, codec compilation, discovery — lives in
+// the instance-scoped helpers/methods so it runs against an explicit
+// *definitions and is testable in isolation (see the withDefs test helper). Any
+// logic added to a wrapper would execute only against this global and slip past
+// the per-instance tests.
+var defs = newDefinitions()
+
+// recordErr appends a registration-phase definition error. agent/method may be
+// "" when the problem is not attributable to one (e.g. a conflicting NameType).
+func (d *definitions) recordErr(agent, method, format string, args ...any) {
+	d.errs = append(d.errs, definitionError{agent: agent, method: method, detail: fmt.Sprintf(format, args...)})
+}
+
+// discover derives every agent type and collects every problem, purely: it reads
+// d but does not mutate it, so it is idempotent and safe to call repeatedly. The
+// returned errors are the registration-phase errors plus everything derivation
+// finds (unsupported types, invalid HTTP routes, intra-agent route collisions).
+func (d *definitions) discover() ([]common.AgentType, []definitionError) {
+	errs := append([]definitionError(nil), d.errs...)
+	var types []common.AgentType
+
+	for _, name := range d.order {
+		e := d.agents[name]
+		at, invalids, err := d.safeBuildAgentType(e)
+		if err != nil {
+			errs = append(errs, definitionError{agent: name, detail: err.Error()})
+			continue
+		}
+		for _, reason := range invalids {
+			// reason already names the offending type (e.g. "int has a
+			// platform-dependent width; …").
+			errs = append(errs, definitionError{agent: name, detail: reason})
+		}
+
+		// HTTP mount/endpoints: validate and compile, patching the built type
+		// with the metadata the platform routes on.
+		mount, endpoints, httpErrs := buildHTTP(e)
+		errs = append(errs, httpErrs...)
+		if mount.IsSome() {
+			at.HttpMount = mount
+			// Route collisions are checked only *within* an agent, where two
+			// methods sharing a verb+path is unconditionally ambiguous. Cross
+			// agent overlap depends on the httpApi deployment topology (agents
+			// may be mounted under different subdomains), which the SDK does not
+			// see — so, like the TS and Rust SDKs, that is left to the host.
+			routeOwners := map[string]string{}
+			prefix := mount.Some().PathPrefix
+			for _, mname := range e.order {
+				for _, det := range endpoints[mname] {
+					key := routeKey(det.HttpMethod, prefix, det.PathSuffix)
+					if prev, seen := routeOwners[key]; seen {
+						if prev == mname {
+							errs = append(errs, definitionError{name, mname, fmt.Sprintf("declares HTTP route %q more than once", key)})
+						} else {
+							errs = append(errs, definitionError{name, mname, fmt.Sprintf("HTTP route %q collides with method %q", key, prev)})
+						}
+					} else {
+						routeOwners[key] = mname
+					}
+				}
+			}
+		}
+		for i := range at.Methods {
+			if eps := endpoints[at.Methods[i].Name]; len(eps) > 0 {
+				at.Methods[i].HttpEndpoint = eps
+			}
+		}
+		types = append(types, at)
+	}
+	return types, errs
+}
+
+// safeBuildAgentType builds an agent's type metadata, converting any panic that
+// slips through (an unconverted edge case in schema derivation) into a recorded
+// error rather than a component-killing trap — the backstop for the no-trap rule.
+func (d *definitions) safeBuildAgentType(e *agentEntry) (at common.AgentType, invalids map[reflect.Type]string, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			err = fmt.Errorf("deriving agent type panicked: %v", r)
+		}
+	}()
+	at, invalids = d.buildAgentType(e)
+	return at, invalids, nil
+}
+
+// agentDefErrors returns the joined details of the errors that block a given
+// agent from being used — its own, plus any global (unattributed) ones — or ""
+// if there are none.
+func agentDefErrors(errs []definitionError, agent string) string {
+	var msgs []string
+	for _, e := range errs {
+		if e.agent == "" || e.agent == agent {
+			msgs = append(msgs, e.Error())
+		}
+	}
+	return strings.Join(msgs, "\n")
+}
+
+// allDefErrors formats every collected error as one message for the wholesale
+// discover-agent-types report.
+func allDefErrors(errs []definitionError) string {
+	msgs := make([]string, 0, len(errs))
+	for _, e := range errs {
+		msgs = append(msgs, "  - "+e.Error())
+	}
+	return fmt.Sprintf("component has %d agent definition error(s):\n%s", len(errs), strings.Join(msgs, "\n"))
+}
+
+// DefinitionErrors returns every problem found while building the component's
+// agent definitions (bad specs, unsupported types, invalid HTTP routes, …).
+// It is empty for a well-formed component. Intended for native tests, which can
+// assert on definitions without deploying; at runtime the same errors surface
+// through discover-agent-types and initialize.
+func DefinitionErrors() []error {
+	_, ds := defs.discover()
+	out := make([]error, len(ds))
+	for i := range ds {
+		out[i] = ds[i]
+	}
+	return out
+}
diff --git a/sdks/go/golem/definition_test.go b/sdks/go/golem/definition_test.go
new file mode 100644
index 0000000000..2542eb3dca
--- /dev/null
+++ b/sdks/go/golem/definition_test.go
@@ -0,0 +1,152 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestDefinitionErrorMessageIsAttributed(t *testing.T) {
+	cases := []struct {
+		err  definitionError
+		want string
+	}{
+		{definitionError{detail: "bad type-id"}, "golem: bad type-id"},
+		{definitionError{agent: "Counter", detail: "Id must be a struct"}, `golem: agent "Counter": Id must be a struct`},
+		{definitionError{agent: "Counter", method: "add", detail: "route var {x} unknown"}, `golem: agent "Counter" method "add": route var {x} unknown`},
+	}
+	for _, c := range cases {
+		if got := c.err.Error(); got != c.want {
+			t.Errorf("Error() = %q, want %q", got, c.want)
+		}
+	}
+}
+
+func TestAgentDefErrorsFiltersByAgentAndGlobal(t *testing.T) {
+	withDefs(t, func(d *definitions) {
+		d.recordErr("", "", "global problem")          // affects every agent
+		d.recordErr("Counter", "", "counter problem")  // only Counter
+		d.recordErr("Ledger", "add", "ledger problem") // only Ledger
+
+		got := agentDefErrors(d.errs, "Counter")
+		if !strings.Contains(got, "global problem") || !strings.Contains(got, "counter problem") {
+			t.Errorf("Counter errors missing global or own: %q", got)
+		}
+		if strings.Contains(got, "ledger problem") {
+			t.Errorf("Counter errors leaked another agent's: %q", got)
+		}
+
+		// An agent with no errors of its own still inherits global ones.
+		if got := agentDefErrors(d.errs, "Unrelated"); !strings.Contains(got, "global problem") || strings.Contains(got, "counter problem") {
+			t.Errorf("Unrelated agent errors = %q", got)
+		}
+	})
+}
+
+func TestPublicAccessors(t *testing.T) {
+	if got := (&Agent[struct{}, struct{}, NoConfig]{name: "N"}).Name(); got != "N" {
+		t.Errorf("Agent.Name = %q", got)
+	}
+	md := DefineMethod[struct{}, struct{}, struct{}]("m", Desc("d"), HTTP(GET("/x")))
+	if md.Name() != "m" {
+		t.Errorf("MethodDef.Name = %q", md.Name())
+	}
+	if len(md.endpoints) != 1 {
+		t.Errorf("HTTP opt: endpoints = %d, want 1", len(md.endpoints))
+	}
+	if got := (&Context[int]{agentID: "aid"}).AgentID(); got != "aid" {
+		t.Errorf("Context.AgentID = %q", got)
+	}
+}
+
+func TestDefinitionErrorsIsCleanForAValidComponent(t *testing.T) {
+	// The test package's registered agents are all well-formed, so the accessor
+	// (which triggers finalize) reports nothing.
+	if errs := DefinitionErrors(); len(errs) != 0 {
+		t.Fatalf("expected no definition errors, got %v", errs)
+	}
+}
+
+func TestAllDefErrorsReportsEveryProblem(t *testing.T) {
+	withDefs(t, func(d *definitions) {
+		d.recordErr("Counter", "", "first")
+		d.recordErr("Ledger", "add", "second")
+		got := allDefErrors(d.errs)
+		if !strings.Contains(got, "2 agent definition error(s)") {
+			t.Errorf("missing count: %q", got)
+		}
+		if !strings.Contains(got, "first") || !strings.Contains(got, "second") {
+			t.Errorf("missing a problem: %q", got)
+		}
+	})
+}
+
+// TestValidAgentFinalizesAndPublishesItsMount — The whole register → discover → publish pipeline, exercised natively over an
+// explicit definitions: a valid agent with a mounted method discovers cleanly and
+// publishes the mount and endpoint. This dumps exactly what discovery produces,
+// with no global state.
+func TestValidAgentFinalizesAndPublishesItsMount(t *testing.T) {
+	type Id struct{ Name string }
+	type St struct{}
+	type AddIn struct{ By int64 }
+	withDefs(t, func(d *definitions) {
+		a := defineAgentInto[Id, St](d,
+			Spec{Name: "Counter", HTTP: &Mount{Path: "/c/{name}"}},
+			func(Id) *St { return &St{} })
+		add := DefineMethod[Id, AddIn, int64]("add", HTTP(POST("/add?by={by}")))
+		implementInto[Id, St, NoConfig, AddIn, int64](d, a, add, func(*Context[St], AddIn) int64 { return 0 })
+
+		types, errs := d.discover()
+		if len(errs) != 0 {
+			t.Fatalf("a valid agent produced errors: %v", errs)
+		}
+		if len(types) != 1 {
+			t.Fatalf("expected 1 agent type, got %d", len(types))
+		}
+		at := types[0]
+		if !at.HttpMount.IsSome() {
+			t.Fatal("mount was not published")
+		}
+		if len(at.Methods) != 1 || at.Methods[0].Name != "add" {
+			t.Fatalf("methods = %+v", at.Methods)
+		}
+		if len(at.Methods[0].HttpEndpoint) != 1 {
+			t.Fatalf("endpoint not published: %+v", at.Methods[0])
+		}
+	})
+}
+
+// TestSeparateDefinitionsDoNotLeak — The same agent name registered into two separate definitions both discover
+// cleanly — isolation is inherent now that registration is instance-based (no
+// shared global to leak between tests).
+func TestSeparateDefinitionsDoNotLeak(t *testing.T) {
+	register := func() []definitionError {
+		type Id struct{ Name string }
+		type St struct{}
+		var errs []definitionError
+		withDefs(t, func(d *definitions) {
+			defineAgentInto[Id, St](d, Spec{Name: "Solo"}, func(Id) *St { return &St{} })
+			_, errs = d.discover()
+		})
+		return errs
+	}
+	if e := register(); len(e) != 0 {
+		t.Fatalf("first registration: %v", e)
+	}
+	if e := register(); len(e) != 0 {
+		t.Fatalf("second registration: %v", e)
+	}
+}
diff --git a/sdks/go/golem/durability.go b/sdks/go/golem/durability.go
new file mode 100644
index 0000000000..8aec21ce86
--- /dev/null
+++ b/sdks/go/golem/durability.go
@@ -0,0 +1,129 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	apiHost "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_host"
+)
+
+// Durability helpers expose Golem's exactly-once execution knobs to a handler:
+// atomic regions, persistence level, idempotence mode, an idempotency-key
+// generator, and oplog commit. They wrap host functions that the runtime already
+// implements; the durability semantics are guaranteed by the executor, and these
+// are thin, fail-loud wrappers (a host failure traps and surfaces as an
+// agent-error, matching the RPC/promise surface — no in-band error return).
+//
+// Concurrency: these knobs apply at the worker level — the scope is currently per
+// worker rather than per goroutine (the same model as the other Golem SDKs).
+// Golem runs an agent single-threaded with cooperative task-switching only at
+// await points (RPC, promise, sleep), so an atomic region or a
+// WithPersistenceLevel/WithIdempotenceMode scope is safe when it does not await
+// while other goroutines run concurrently; nesting on a single logical flow is
+// fine. To keep a scope from affecting concurrent work, don't hold it open across
+// a concurrent await (e.g. a CallAsync fan-out); for concurrency, distribute work
+// across agent instances.
+
+// Atomically runs f as an atomic region: on normal return the region commits, so
+// on a later replay it is treated as a single completed step. If f panics, the
+// region is left open (MarkEndOperation is never reached) and the runtime
+// re-executes the whole region on retry — all-or-nothing. Panicking is therefore
+// the way to abort a region, consistent with the fail-loud RPC/promise model.
+//
+// Return a value by capturing it in an outer variable:
+//
+//	var total int64
+//	golem.Atomically(func() { total = recompute() })
+func Atomically(f func()) {
+	begin := apiHost.MarkBeginOperation()
+	f() // if this panics, the region stays open and is replayed on retry
+	apiHost.MarkEndOperation(begin)
+}
+
+// PersistenceLevel controls how much of an agent's execution is written to the
+// oplog. Lowering it speeds up execution where durable replay is not required.
+type PersistenceLevel int
+
+const (
+	// PersistNothing does not persist side effects; such a zone is skipped on
+	// replay. Use only for work that is safe to re-run or that you re-derive.
+	PersistNothing PersistenceLevel = iota
+	// PersistRemoteSideEffects persists remote side effects (e.g. RPC results).
+	PersistRemoteSideEffects
+	// PersistSmart is the default heuristic.
+	PersistSmart
+)
+
+func (l PersistenceLevel) toWit() apiHost.PersistenceLevel {
+	switch l {
+	case PersistNothing:
+		return apiHost.MakePersistenceLevelPersistNothing()
+	case PersistRemoteSideEffects:
+		return apiHost.MakePersistenceLevelPersistRemoteSideEffects()
+	default:
+		return apiHost.MakePersistenceLevelSmart()
+	}
+}
+
+func persistenceLevelFromWit(w apiHost.PersistenceLevel) PersistenceLevel {
+	switch w.Tag() {
+	case apiHost.PersistenceLevelPersistNothing:
+		return PersistNothing
+	case apiHost.PersistenceLevelPersistRemoteSideEffects:
+		return PersistRemoteSideEffects
+	default:
+		return PersistSmart
+	}
+}
+
+// WithPersistenceLevel sets the current persistence level and returns a function
+// that restores the previous level. Use it with defer to scope a level to the
+// rest of the current function:
+//
+//	defer golem.WithPersistenceLevel(golem.PersistNothing)()
+//
+// Scope a sub-block by wrapping it in a function literal with its own defer.
+func WithPersistenceLevel(level PersistenceLevel) (restore func()) {
+	prev := persistenceLevelFromWit(apiHost.GetOplogPersistenceLevel())
+	apiHost.SetOplogPersistenceLevel(level.toWit())
+	return func() { apiHost.SetOplogPersistenceLevel(prev.toWit()) }
+}
+
+// WithIdempotenceMode sets the current idempotence mode and returns a function
+// that restores the previous mode; use it with defer to scope it:
+//
+//	defer golem.WithIdempotenceMode(false)()
+//
+// The default is true — side effects are treated as idempotent and Golem gives
+// at-least-once semantics. Setting it false gives at-most-once: the agent fails
+// if it is unknown whether a side effect already ran.
+func WithIdempotenceMode(idempotent bool) (restore func()) {
+	prev := apiHost.GetIdempotenceMode()
+	apiHost.SetIdempotenceMode(idempotent)
+	return func() { apiHost.SetIdempotenceMode(prev) }
+}
+
+// GenerateIdempotencyKey returns a fresh idempotency key that is stable across
+// replay — it is persisted and committed, so it can be handed to a third-party
+// system (e.g. a payment processor) to make an external call idempotent.
+func GenerateIdempotencyKey() UUID {
+	return uuidFromWit(apiHost.GenerateIdempotencyKey())
+}
+
+// OplogCommit blocks until the oplog has been written to at least the given
+// number of replicas (capped at the maximum available). Use it before a critical
+// external effect to bound how much progress a crash could lose.
+func OplogCommit(replicas uint8) {
+	apiHost.OplogCommit(replicas)
+}
diff --git a/sdks/go/golem/durability_test.go b/sdks/go/golem/durability_test.go
new file mode 100644
index 0000000000..a71f4b2923
--- /dev/null
+++ b/sdks/go/golem/durability_test.go
@@ -0,0 +1,43 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"testing"
+
+	apiHost "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_host"
+)
+
+// TestPersistenceLevelRoundTrip — each level survives conversion to the host wire
+// form and back, and maps to the expected host tag.
+func TestPersistenceLevelRoundTrip(t *testing.T) {
+	cases := []struct {
+		level PersistenceLevel
+		tag   uint8
+	}{
+		{PersistNothing, apiHost.PersistenceLevelPersistNothing},
+		{PersistRemoteSideEffects, apiHost.PersistenceLevelPersistRemoteSideEffects},
+		{PersistSmart, apiHost.PersistenceLevelSmart},
+	}
+	for _, c := range cases {
+		w := c.level.toWit()
+		if w.Tag() != c.tag {
+			t.Fatalf("%v toWit tag = %d, want %d", c.level, w.Tag(), c.tag)
+		}
+		if got := persistenceLevelFromWit(w); got != c.level {
+			t.Fatalf("round-trip = %v, want %v", got, c.level)
+		}
+	}
+}
diff --git a/sdks/go/golem/future.go b/sdks/go/golem/future.go
new file mode 100644
index 0000000000..002bbb5c07
--- /dev/null
+++ b/sdks/go/golem/future.go
@@ -0,0 +1,76 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"fmt"
+
+	host "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_host"
+)
+
+// Future is an invocation that has been started but not yet awaited, returned by
+// [MethodDef.CallAsync].
+//
+// Several futures can be in flight at once. This is the SDK's only source of
+// concurrency: `invoke-and-await` is a synchronous import that blocks the whole
+// component, while a future's Get is async, so a goroutine blocked in Get yields
+// to the component-model event loop and lets other goroutines run.
+//
+// It wraps the host resource rather than replacing it — a handle, not data, so
+// nothing here crosses the schema marshaler.
+type Future[Out any] struct {
+	// ID identifies the invocation, available before the result is.
+	ID InvocationID
+
+	fut    *host.FutureInvokeResult
+	method string
+	target string
+}
+
+// Get waits for the invocation to finish and returns its result, panicking on an
+// infra failure (a [RemoteCallError]) — fail-loud, like [MethodDef.Call], to align
+// with Golem's exactly-once model. Model expected outcomes as a [Result] in Out.
+//
+// It consumes the future: the underlying host handle is owned, so it is dropped
+// here and a second call panics rather than reusing a freed handle.
+func (f *Future[Out]) Get() Out {
+	if f == nil || f.fut == nil {
+		panic(fmt.Errorf("golem: Get on an already-consumed or zero Future"))
+	}
+
+	res := f.fut.Get()
+	f.fut.Drop()
+	f.fut = nil
+
+	if res.IsErr() {
+		panic(rpcErrorToGo(f.target, f.method, res.Err()))
+	}
+	out, err := decodeOutput[Out](f.target, f.method, res.Ok())
+	if err != nil {
+		panic(err)
+	}
+	return out
+}
+
+// Cancel makes a best-effort attempt to cancel the invocation. It is a no-op if
+// the invocation already started or finished, and it consumes the future.
+func (f *Future[Out]) Cancel() {
+	if f == nil || f.fut == nil {
+		return
+	}
+	f.fut.Cancel()
+	f.fut.Drop()
+	f.fut = nil
+}
diff --git a/sdks/go/golem/go.mod b/sdks/go/golem/go.mod
new file mode 100644
index 0000000000..674164f2d2
--- /dev/null
+++ b/sdks/go/golem/go.mod
@@ -0,0 +1,13 @@
+module github.com/golemcloud/golem/sdks/go/golem
+
+go 1.25.5
+
+tool github.com/bytecodealliance/componentize-go
+
+require (
+	github.com/apparentlymart/go-userdirs v0.0.0-20200915174352-b0c018a67c13 // indirect
+	github.com/bytecodealliance/componentize-go v0.4.0 // indirect
+	github.com/gofrs/flock v0.13.0 // indirect
+	go.bytecodealliance.org/pkg v0.2.3 // indirect
+	golang.org/x/sys v0.37.0 // indirect
+)
diff --git a/sdks/go/golem/go.sum b/sdks/go/golem/go.sum
new file mode 100644
index 0000000000..b7afa3cea1
--- /dev/null
+++ b/sdks/go/golem/go.sum
@@ -0,0 +1,12 @@
+github.com/apparentlymart/go-userdirs v0.0.0-20200915174352-b0c018a67c13 h1:JtuelWqyixKApmXm3qghhZ7O96P6NKpyrlSIe8Rwnhw=
+github.com/apparentlymart/go-userdirs v0.0.0-20200915174352-b0c018a67c13/go.mod h1:7kfpUbyCdGJ9fDRCp3fopPQi5+cKNHgTE4ZuNrO71Cw=
+github.com/bytecodealliance/componentize-go v0.4.0 h1:rzNC0pnrXl2PGaTlXkVnAvw9IH6JLMN5K49SYBcYEdU=
+github.com/bytecodealliance/componentize-go v0.4.0/go.mod h1:w1QFtPLGI9o38epvMOPyCKbMc7q7GJ7yZhIvhGTpzA0=
+github.com/gofrs/flock v0.13.0 h1:95JolYOvGMqeH31+FC7D2+uULf6mG61mEZ/A8dRYMzw=
+github.com/gofrs/flock v0.13.0/go.mod h1:jxeyy9R1auM5S6JYDBhDt+E2TCo7DkratH4Pgi8P+Z0=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+go.bytecodealliance.org/pkg v0.2.3 h1:So9zHg8ahW+TH1JmgBHgIYuKHcinLiEcpV1tqVEZvLA=
+go.bytecodealliance.org/pkg v0.2.3/go.mod h1:OjA+V8g3uUFixeCKFfamm6sYhTJdg8fvwEdJ2GO0GSk=
+golang.org/x/sys v0.0.0-20190509141414-a5b02f93d862/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
+golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
diff --git a/sdks/go/golem/golem.go b/sdks/go/golem/golem.go
new file mode 100644
index 0000000000..c2bc78bb95
--- /dev/null
+++ b/sdks/go/golem/golem.go
@@ -0,0 +1,323 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem is the Golem Go SDK for authoring agents.
+//
+// An agent is declared with [DefineAgent], its methods with [DefineMethod], and
+// their behaviour bound with [Implement]:
+//
+//	type CounterId struct{ Name string }     // constructor params; also the type-level marker
+//	type CounterState struct{ count int64 }  // private state
+//	type AddIn struct{ By int64 }
+//
+//	var Counter = golem.DefineAgent[CounterId, CounterState](
+//	    golem.Spec{Name: "CounterAgent", Mode: golem.Durable},
+//	    func(id CounterId) *CounterState { return &CounterState{} },
+//	)
+//
+//	var Add = golem.DefineMethod[CounterId, AddIn, int64]("add")
+//
+//	func init() {
+//	    golem.Implement(Counter, Add, func(ctx *golem.Context[CounterState], in AddIn) int64 {
+//	        ctx.State.count += in.By
+//	        return ctx.State.count
+//	    })
+//	}
+//
+//	func main() {} // the SDK wires the component exports from its own init()
+//
+// Method descriptors are package-level values so the same value drives the
+// agent-type schema, the implementation binding, and (typed) calls from other
+// agents. Schemas are derived from the Go types by reflection; there is no code
+// generation step.
+//
+// Importing this package links the generated golem:agent/guest export glue into
+// the component, so an agent's main package needs only:
+//
+//	import _ "github.com/golemcloud/golem/sdks/go/golem"
+package golem
+
+import (
+	"time"
+
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+
+	// Links the generated wasmexport glue into the component.
+	_ "github.com/golemcloud/golem/sdks/go/golem/internal/wit/wit_exports"
+)
+
+// Unit is the empty input/output marker. Go has no arity overloading, so a
+// method with no parameters takes Unit, and one with no result returns Unit.
+type Unit struct{}
+
+// Mode selects an agent's durability model.
+type Mode uint8
+
+const (
+	// Durable agents persist their state and replay deterministically.
+	Durable Mode = iota
+	// Ephemeral agents do not persist state across invocations.
+	Ephemeral
+)
+
+func (m Mode) toWit() common.AgentMode {
+	if m == Ephemeral {
+		return common.AgentModeEphemeral
+	}
+	return common.AgentModeDurable
+}
+
+// SnapshotPolicy declares whether and how often the platform snapshots an
+// agent's state. The zero value is [SnapshotDisabled]. Build one with
+// [SnapshotDefault], [SnapshotPeriodic], or [SnapshotEveryN].
+//
+// A snapshot serializes the agent's state: if the state implements
+// [Snapshotter], that is used; otherwise the exported fields are JSON-encoded
+// (see [Snapshotter] for the caveat).
+type SnapshotPolicy struct {
+	kind   snapshotKind
+	amount uint64 // periodic: nanoseconds; every-n: count
+}
+
+type snapshotKind uint8
+
+const (
+	snapDisabled snapshotKind = iota
+	snapDefault
+	snapPeriodic
+	snapEveryN
+)
+
+// SnapshotDisabled is the zero-value policy: the platform never snapshots.
+var SnapshotDisabled = SnapshotPolicy{kind: snapDisabled}
+
+// SnapshotDefault enables snapshotting at the platform's default cadence.
+var SnapshotDefault = SnapshotPolicy{kind: snapDefault}
+
+// SnapshotPeriodic snapshots on a fixed time interval.
+func SnapshotPeriodic(d time.Duration) SnapshotPolicy {
+	return SnapshotPolicy{kind: snapPeriodic, amount: uint64(d.Nanoseconds())}
+}
+
+// SnapshotEveryN snapshots every n invocations.
+func SnapshotEveryN(n uint16) SnapshotPolicy {
+	return SnapshotPolicy{kind: snapEveryN, amount: uint64(n)}
+}
+
+func (p SnapshotPolicy) toWit() common.Snapshotting {
+	switch p.kind {
+	case snapDefault:
+		return common.MakeSnapshottingEnabled(common.MakeSnapshottingConfigDefault())
+	case snapPeriodic:
+		return common.MakeSnapshottingEnabled(common.MakeSnapshottingConfigPeriodic(p.amount))
+	case snapEveryN:
+		return common.MakeSnapshottingEnabled(common.MakeSnapshottingConfigEveryNInvocation(uint16(p.amount)))
+	default:
+		return common.MakeSnapshottingDisabled()
+	}
+}
+
+// Snapshotter lets an agent's state control its own snapshot serialization.
+// Implement it on the state type (usually with a pointer receiver) when the
+// default reflective snapshot is not enough — in particular, Go reflection
+// cannot see unexported fields, so the idiomatic private state (e.g. an
+// unexported `count`) is only captured through a Snapshotter. Without one, the
+// snapshot is the JSON of the state's exported fields.
+type Snapshotter interface {
+	Save() ([]byte, error)
+	Load([]byte) error
+}
+
+// Spec is the declarative part of an agent definition.
+type Spec struct {
+	// Name is the wire-level agent type name (as seen by the platform and by
+	// other agents). Required.
+	Name string
+	// Description is surfaced in the agent type metadata.
+	Description string
+	// Mode defaults to Durable.
+	Mode Mode
+	// HTTP, when set, mounts the agent's methods under an HTTP path prefix so the
+	// platform can route requests to them. The prefix binds the Id fields; see
+	// [Mount] and attach per-method routes with [HTTP].
+	HTTP *Mount
+	// Snapshot sets the agent's snapshot policy; the zero value is
+	// [SnapshotDisabled]. See [SnapshotPolicy] and [Snapshotter].
+	Snapshot SnapshotPolicy
+}
+
+// Context is passed to every method handler. State is the agent instance's
+// private state, as returned by the agent's init function.
+type Context[S any] struct {
+	State   *S
+	agentID string
+}
+
+// AgentID returns the raw agent id the running instance was initialized with.
+func (c *Context[S]) AgentID() string { return c.agentID }
+
+// agentScope is the unexported capability carried by a method's *[Context].
+// [Agent.Config] requires it, so config can be read only from inside a running
+// method. The *S in the signature ties the scope to the agent's state type, so
+// one agent cannot read another agent's config (whose state type differs) at
+// compile time. (A constructor reads config off its own *[InitContext] via
+// [InitContext.Config], so it is not an agentScope.)
+type agentScope[S any] interface {
+	agentScopeState() *S
+}
+
+// agentScopeState satisfies [agentScope] for a method context. It exists only to
+// gate [Agent.Config] at compile time.
+//
+//nolint:unused // false positive: staticcheck's unused can't trace generic-interface satisfaction (verified with a minimal repro); the compiler requires this method for agentScope[S].
+func (c *Context[S]) agentScopeState() *S { return c.State }
+
+// InitContext is the execution scope passed to a [DefineConfiguredAgent]
+// constructor. It carries the constructor parameters ([InitContext.ID]) and reads
+// the agent's config with [InitContext.Config]. Its Cfg type parameter is what
+// lets Config return the agent's own config type without a type parameter on the
+// method. Agents declared with the plain [DefineAgent] receive their id directly
+// and never see this type.
+type InitContext[Id any, S any, Cfg any] struct {
+	id      Id
+	agentID string
+}
+
+// ID returns the constructor parameters the agent instance was created with.
+func (c *InitContext[Id, S, Cfg]) ID() Id { return c.id }
+
+// AgentID returns the raw agent id the instance is being initialized with.
+func (c *InitContext[Id, S, Cfg]) AgentID() string { return c.agentID }
+
+// Agent is the handle returned by [DefineAgent] / [DefineConfiguredAgent]. Id is
+// the constructor parameter type, which doubles as the agent's type-level
+// identity; S is the private state type; Cfg is the agent's config struct
+// ([NoConfig] for a config-less agent). Cfg is carried on the handle so config
+// can be read in a method via [Agent.Config] without a separate config handle.
+type Agent[Id any, S any, Cfg any] struct{ name string }
+
+// Name returns the agent's wire-level type name.
+func (a *Agent[Id, S, Cfg]) Name() string { return a.name }
+
+// MethodDef is a typed method descriptor: the single source of truth shared by
+// the agent-type schema, the implementation binding, and calls from other
+// agents. Id is the target agent's identity type, so a descriptor cannot be
+// used against another agent's client.
+type MethodDef[Id any, In any, Out any] struct {
+	name          string
+	desc          string
+	descCount     int // how many times Desc was set; validated at Implement time
+	endpoints     []Endpoint
+	readOnly      *readOnlyConfig // non-nil => method is read-only; validated at Implement
+	readOnlyCount int             // how many times ReadOnly was set
+	cacheCount    int             // how many CachePolicy args were passed to ReadOnly
+}
+
+// Name returns the method's wire-level name.
+func (m MethodDef[Id, In, Out]) Name() string { return m.name }
+
+// MethodOpt configures a method descriptor.
+type MethodOpt func(*methodOpts)
+
+type methodOpts struct {
+	desc          string
+	descCount     int
+	endpoints     []Endpoint
+	readOnly      *readOnlyConfig
+	readOnlyCount int
+	cacheCount    int
+}
+
+// Desc sets a method's description, surfaced in the agent type metadata. Setting
+// it more than once for the same method is a definition error, not a silent
+// overwrite.
+func Desc(s string) MethodOpt {
+	return func(o *methodOpts) { o.desc = s; o.descCount++ }
+}
+
+// HTTP exposes a method over HTTP at one or more routes (the agent must also
+// declare a [Mount] on its [Spec]). Grouping the endpoints in a single option
+// keeps each route's bindings together:
+//
+//	golem.DefineMethod[CounterID, AddIn, int64]("add",
+//	    golem.HTTP(golem.POST("/add?by={by}"), golem.GET("/add/{by}")))
+func HTTP(endpoints ...Endpoint) MethodOpt {
+	return func(o *methodOpts) { o.endpoints = append(o.endpoints, endpoints...) }
+}
+
+// CachePolicy controls how a read-only method's result is cached. Build one with
+// [NoCache], [CacheUntilWrite], or [CacheFor], and pass it to [ReadOnly]. Its zero
+// value is CacheUntilWrite.
+type CachePolicy struct {
+	kind cacheKind
+	ttl  time.Duration // for cacheTTL
+}
+
+type cacheKind uint8
+
+const (
+	cacheUntilWrite cacheKind = iota // zero value = the default policy
+	cacheNone
+	cacheTTL
+)
+
+// NoCache never caches the method's result (the method still runs read-only).
+func NoCache() CachePolicy { return CachePolicy{kind: cacheNone} }
+
+// CacheUntilWrite caches the result until any mutating (non-read-only) method of
+// the agent completes. It is the default policy for [ReadOnly].
+func CacheUntilWrite() CachePolicy { return CachePolicy{kind: cacheUntilWrite} }
+
+// CacheFor caches the result for the given duration. ttl must be positive; a
+// zero/negative ttl is a definition error (use [NoCache] to disable caching).
+func CacheFor(ttl time.Duration) CachePolicy { return CachePolicy{kind: cacheTTL, ttl: ttl} }
+
+func (c CachePolicy) toWit() common.CachePolicy {
+	switch c.kind {
+	case cacheNone:
+		return common.MakeCachePolicyNoCache()
+	case cacheTTL:
+		return common.MakeCachePolicyTtl(uint64(c.ttl.Nanoseconds()))
+	default:
+		return common.MakeCachePolicyUntilWrite()
+	}
+}
+
+type readOnlyConfig struct {
+	policy CachePolicy
+	// usesPrincipal is always false until the SDK has a Principal parameter type;
+	// the other SDKs derive it from a Principal method parameter.
+}
+
+// ReadOnly marks a method read-only: it must not perform remote side effects —
+// the runtime traps outgoing HTTP and agent RPC from a read-only method — and in
+// return its result is cached per the [CachePolicy]. With no argument the policy
+// is [CacheUntilWrite]; pass at most one policy. Read-only is only valid on
+// Durable agents (an [Ephemeral] agent has no shared state to read); violating
+// that, passing more than one policy, or setting ReadOnly more than once is a
+// definition error reported at discovery.
+//
+//	golem.DefineMethod[ShopId, golem.Unit, Catalog]("catalog", golem.ReadOnly())
+//	golem.DefineMethod[ShopId, golem.Unit, Rates]("rates", golem.ReadOnly(golem.CacheFor(time.Minute)))
+func ReadOnly(cache ...CachePolicy) MethodOpt {
+	return func(o *methodOpts) {
+		o.readOnlyCount++
+		o.cacheCount += len(cache)
+		rc := &readOnlyConfig{policy: CacheUntilWrite()}
+		if len(cache) >= 1 {
+			rc.policy = cache[0]
+		}
+		o.readOnly = rc
+	}
+}
diff --git a/sdks/go/golem/golem_test.go b/sdks/go/golem/golem_test.go
new file mode 100644
index 0000000000..ff9e536920
--- /dev/null
+++ b/sdks/go/golem/golem_test.go
@@ -0,0 +1,333 @@
+package golem
+
+import (
+	"strings"
+	"testing"
+
+	guestExports "github.com/golemcloud/golem/sdks/go/golem/internal/exports/export_golem_agent_guest"
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+)
+
+// These tests run natively (host arch): they exercise the real export slots and
+// the real dispatch path. That works because the generated bindings compile for
+// the host; only *calling* a host import would be a link error.
+
+type tCounterId struct{ Name string }
+type tCounterState struct{ count int64 }
+type tAddIn struct{ By int64 }
+
+var tCounter = DefineAgent[tCounterId, tCounterState](
+	Spec{Name: "TestCounter", Description: "counter under test", Mode: Durable},
+	func(id tCounterId) *tCounterState { return &tCounterState{} },
+)
+
+var (
+	tValue = DefineMethod[tCounterId, Unit, int64]("value", Desc("current value"))
+	tInc   = DefineMethod[tCounterId, Unit, int64]("increment")
+	tAdd   = DefineMethod[tCounterId, tAddIn, int64]("add")
+	tReset = DefineMethod[tCounterId, Unit, Unit]("reset")
+	tBoom  = DefineMethod[tCounterId, Unit, int64]("boom")
+)
+
+func init() {
+	Implement(tCounter, tValue, func(ctx *Context[tCounterState], _ Unit) int64 {
+		return ctx.State.count
+	})
+	Implement(tCounter, tInc, func(ctx *Context[tCounterState], _ Unit) int64 {
+		ctx.State.count++
+		return ctx.State.count
+	})
+	Implement(tCounter, tAdd, func(ctx *Context[tCounterState], in tAddIn) int64 {
+		ctx.State.count += in.By
+		return ctx.State.count
+	})
+	Implement(tCounter, tReset, Bind0Unit((*tCounterState).reset)) // method-expression binding
+	Implement(tCounter, tBoom, func(*Context[tCounterState], Unit) int64 {
+		panic("kaboom from agent code")
+	})
+}
+
+func (s *tCounterState) reset() { s.count = 0 }
+
+// params builds a parameter-list tree: a record whose fields are the values.
+func params(vals ...types.SchemaValueNode) types.SchemaValueTree {
+	nodes := make([]types.SchemaValueNode, 0, len(vals)+1)
+	idxs := make([]int32, 0, len(vals))
+	for _, v := range vals {
+		idxs = append(idxs, int32(len(nodes)))
+		nodes = append(nodes, v)
+	}
+	root := int32(len(nodes))
+	nodes = append(nodes, types.MakeSchemaValueNodeRecordValue(idxs))
+	return types.SchemaValueTree{ValueNodes: nodes, Root: root}
+}
+
+func initAgent(t *testing.T) {
+	t.Helper()
+	active = nil // fresh instance per test
+	res := guestExports.Initialize("TestCounter", params(types.MakeSchemaValueNodeStringValue("x")), common.MakePrincipalAnonymous())
+	if res.IsErr() {
+		t.Fatalf("initialize failed: %v", res.Err())
+	}
+}
+
+func invokeInt(t *testing.T, method string, in types.SchemaValueTree) int64 {
+	t.Helper()
+	res := guestExports.Invoke(method, in, common.MakePrincipalAnonymous())
+	if res.IsErr() {
+		t.Fatalf("%s errored: %v", method, res.Err())
+	}
+	opt := res.Ok()
+	if opt.IsNone() {
+		t.Fatalf("%s returned none, expected a value", method)
+	}
+	tree := opt.Some()
+	return tree.ValueNodes[tree.Root].S64Value()
+}
+
+func TestCounterRoundTrip(t *testing.T) {
+	initAgent(t)
+	if got := invokeInt(t, "increment", params()); got != 1 {
+		t.Fatalf("increment = %d, want 1", got)
+	}
+	if got := invokeInt(t, "add", params(types.MakeSchemaValueNodeS64Value(5))); got != 6 {
+		t.Fatalf("add(5) = %d, want 6", got)
+	}
+	if got := invokeInt(t, "value", params()); got != 6 {
+		t.Fatalf("value = %d, want 6", got)
+	}
+	// reset returns unit => ok(none); bound via a method expression
+	res := guestExports.Invoke("reset", params(), common.MakePrincipalAnonymous())
+	if res.IsErr() || !res.Ok().IsNone() {
+		t.Fatal("reset should succeed and return none (unit output)")
+	}
+	if got := invokeInt(t, "value", params()); got != 0 {
+		t.Fatalf("value after reset = %d, want 0", got)
+	}
+}
+
+func TestGetDefinitionDerivesSchemaFromGoTypes(t *testing.T) {
+	initAgent(t)
+	def := guestExports.GetDefinition()
+	if def.TypeName != "TestCounter" || def.SourceLanguage != "go" {
+		t.Fatalf("type name = %q, source = %q", def.TypeName, def.SourceLanguage)
+	}
+	if len(def.Methods) != 5 {
+		t.Fatalf("methods = %d, want 5", len(def.Methods))
+	}
+	// constructor: one parameter, named after the Id field, typed string
+	ctor := def.Constructor.InputSchema.Parameters()
+	if len(ctor) != 1 || ctor[0].Name != "name" {
+		t.Fatalf("constructor params = %+v", ctor)
+	}
+	if body := def.Schema.TypeNodes[ctor[0].Schema].Body; body.Tag() != types.SchemaTypeBodyStringType {
+		t.Fatalf("constructor param type tag = %d, want string", body.Tag())
+	}
+	// add: one s64 parameter, s64 output
+	var add *common.AgentMethod
+	for i := range def.Methods {
+		if def.Methods[i].Name == "add" {
+			add = &def.Methods[i]
+		}
+	}
+	if add == nil {
+		t.Fatal("method add missing")
+	}
+	if add.Description != "" && add.Description != "add" {
+		_ = add.Description // description is optional here
+	}
+	in := add.InputSchema.Parameters()
+	if len(in) != 1 || in[0].Name != "by" {
+		t.Fatalf("add params = %+v", in)
+	}
+	if tag := def.Schema.TypeNodes[in[0].Schema].Body.Tag(); tag != types.SchemaTypeBodyS64Type {
+		t.Fatalf("add param type tag = %d, want s64", tag)
+	}
+	if add.OutputSchema.Tag() != common.OutputSchemaSingle {
+		t.Fatal("add should have a single output")
+	}
+	// reset: unit output
+	for i := range def.Methods {
+		if def.Methods[i].Name == "reset" && def.Methods[i].OutputSchema.Tag() != common.OutputSchemaUnit {
+			t.Fatal("reset should have a unit output")
+		}
+	}
+}
+
+func TestDiscoverAgentTypes(t *testing.T) {
+	res := guestExports.DiscoverAgentTypes()
+	if res.IsErr() {
+		t.Fatalf("discover errored: %v", res.Err())
+	}
+	found := false
+	for _, at := range res.Ok() {
+		if at.TypeName == "TestCounter" {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatal("TestCounter not discovered")
+	}
+}
+
+func TestPanicBecomesCustomErrorAndAgentSurvives(t *testing.T) {
+	initAgent(t)
+	res := guestExports.Invoke("boom", params(), common.MakePrincipalAnonymous())
+	if !res.IsErr() {
+		t.Fatal("a panicking method must surface as an agent-error")
+	}
+	if tag := res.Err().Tag(); tag != common.AgentErrorCustomError {
+		t.Fatalf("panic mapped to tag %d, want custom-error", tag)
+	}
+	// the component must still be usable afterwards
+	if got := invokeInt(t, "value", params()); got != 0 {
+		t.Fatalf("agent unusable after panic; value = %d", got)
+	}
+}
+
+func TestUnknownMethodAndBadInputAreDistinguished(t *testing.T) {
+	initAgent(t)
+	res := guestExports.Invoke("nope", params(), common.MakePrincipalAnonymous())
+	if !res.IsErr() || res.Err().Tag() != common.AgentErrorInvalidMethod {
+		t.Fatal("unknown method should map to invalid-method")
+	}
+	// add expects an s64; hand it a string instead
+	bad := guestExports.Invoke("add", params(types.MakeSchemaValueNodeStringValue("nope")), common.MakePrincipalAnonymous())
+	if !bad.IsErr() || bad.Err().Tag() != common.AgentErrorInvalidInput {
+		t.Fatalf("malformed input should map to invalid-input, got tag %d", bad.Err().Tag())
+	}
+}
+
+func TestPanicErrorAttribution(t *testing.T) {
+	agentSide := &PanicError{Method: "m", Stage: stageHandler, Value: "boom"}
+	if agentSide.Internal() {
+		t.Fatal("a handler panic is not an SDK bug")
+	}
+	if !strings.Contains(agentSide.Error(), `agent method "m" panicked`) {
+		t.Fatalf("unexpected message: %s", agentSide)
+	}
+	sdkSide := &PanicError{Method: "m", Stage: stageEncode, Value: "boom"}
+	if !sdkSide.Internal() || !strings.Contains(sdkSide.Error(), "INTERNAL SDK ERROR") {
+		t.Fatalf("unexpected message: %s", sdkSide)
+	}
+
+	// An encode-stage panic caused by the agent returning an unencodable value is
+	// the agent's mistake, not an SDK bug — even though it occurs in encode.
+	userSide := &PanicError{Method: "m", Stage: stageEncode, Value: &encodeError{"not a registered case"}}
+	if userSide.Internal() {
+		t.Fatal("an unencodable agent value is not an SDK bug")
+	}
+	if msg := userSide.Error(); strings.Contains(msg, "INTERNAL SDK ERROR") ||
+		!strings.Contains(msg, "cannot be encoded") {
+		t.Fatalf("unexpected message: %s", msg)
+	}
+}
+
+// A component may define several agent types; a worker is initialized as exactly
+// one of them, and invoke must route into that one's methods only.
+
+type tEchoId struct{ Prefix string }
+type tEchoState struct{ prefix string }
+type tEchoIn struct{ Msg string }
+
+var tEcho = DefineAgent[tEchoId, tEchoState](
+	Spec{Name: "TestEcho", Mode: Ephemeral},
+	func(id tEchoId) *tEchoState { return &tEchoState{prefix: id.Prefix} },
+)
+
+var tSay = DefineMethod[tEchoId, tEchoIn, string]("say")
+
+func init() {
+	Implement(tEcho, tSay, func(ctx *Context[tEchoState], in tEchoIn) string {
+		return ctx.State.prefix + in.Msg
+	})
+}
+
+func TestWorkerRunsOneOfSeveralAgentTypes(t *testing.T) {
+	active = nil
+	res := guestExports.Initialize("TestEcho", params(types.MakeSchemaValueNodeStringValue("> ")),
+		common.MakePrincipalAnonymous())
+	if res.IsErr() {
+		t.Fatalf("initialize failed: %v", res.Err())
+	}
+	// constructor params reached the state
+	out := guestExports.Invoke("say", params(types.MakeSchemaValueNodeStringValue("hi")), common.MakePrincipalAnonymous())
+	if out.IsErr() {
+		t.Fatalf("say errored: %v", out.Err())
+	}
+	tree := out.Ok().Some()
+	if got := tree.ValueNodes[tree.Root].StringValue(); got != "> hi" {
+		t.Fatalf("say = %q, want %q", got, "> hi")
+	}
+	// the other agent's methods are not reachable from this worker
+	if r := guestExports.Invoke("increment", params(), common.MakePrincipalAnonymous()); !r.IsErr() {
+		t.Fatal("TestCounter's method must not be invocable on a TestEcho worker")
+	}
+	// get-definition reports the agent this worker was initialized as
+	if def := guestExports.GetDefinition(); def.TypeName != "TestEcho" || def.Mode != common.AgentModeEphemeral {
+		t.Fatalf("definition = %q mode %d, want TestEcho/ephemeral", def.TypeName, def.Mode)
+	}
+	// initializing twice is refused
+	if again := guestExports.Initialize("TestEcho", params(types.MakeSchemaValueNodeStringValue("x")),
+		common.MakePrincipalAnonymous()); !again.IsErr() {
+		t.Fatal("re-initializing an already-initialized worker must fail")
+	}
+	// unknown agent type
+	active = nil
+	if bad := guestExports.Initialize("NoSuchAgent", params(), common.MakePrincipalAnonymous()); !bad.IsErr() ||
+		bad.Err().Tag() != common.AgentErrorInvalidType {
+		t.Fatal("unknown agent type should map to invalid-type")
+	}
+}
+
+// tPay — Regression: a method whose declared output is an interface (a variant) must
+// keep that declared type through encoding. reflect.ValueOf on an interface
+// yields the concrete type it holds, so encoding the handler result directly
+// would look up the wrong codec.
+var tPay = DefineMethod[tEchoId, Unit, PaymentMethod]("pay")
+
+func init() {
+	Implement(tEcho, tPay, func(*Context[tEchoState], Unit) PaymentMethod {
+		return Transfer{IBAN: "GB33"}
+	})
+}
+
+func TestVariantTypedMethodOutputRoundTripsThroughTheExports(t *testing.T) {
+	active = nil
+	if res := guestExports.Initialize("TestEcho", params(types.MakeSchemaValueNodeStringValue("> ")),
+		common.MakePrincipalAnonymous()); res.IsErr() {
+		t.Fatalf("initialize failed: %v", res.Err())
+	}
+
+	out := guestExports.Invoke("pay", params(), common.MakePrincipalAnonymous())
+	if out.IsErr() {
+		t.Fatalf("pay errored: %v", out.Err())
+	}
+	tree := out.Ok().Some()
+	node := tree.ValueNodes[tree.Root]
+	if node.Tag() != types.SchemaValueNodeVariantValue {
+		t.Fatalf("expected a variant value, got tag %d", node.Tag())
+	}
+	if got := node.VariantValue().Case; got != 2 {
+		t.Fatalf("case index = %d, want 2 (transfer)", got)
+	}
+
+	// and the published schema agrees
+	def := guestExports.GetDefinition()
+	var pay *common.AgentMethod
+	for i := range def.Methods {
+		if def.Methods[i].Name == "pay" {
+			pay = &def.Methods[i]
+		}
+	}
+	if pay == nil {
+		t.Fatal("method pay missing from the definition")
+	}
+	if pay.OutputSchema.Tag() != common.OutputSchemaSingle {
+		t.Fatal("pay should declare a single output")
+	}
+	if body := def.Schema.TypeNodes[pay.OutputSchema.Single()].Body; body.Tag() != types.SchemaTypeBodyVariantType {
+		t.Fatalf("pay output type tag = %d, want variant", body.Tag())
+	}
+}
diff --git a/sdks/go/golem/guest.go b/sdks/go/golem/guest.go
new file mode 100644
index 0000000000..5fff567810
--- /dev/null
+++ b/sdks/go/golem/guest.go
@@ -0,0 +1,227 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"reflect"
+
+	guestExports "github.com/golemcloud/golem/sdks/go/golem/internal/exports/export_golem_agent_guest"
+	loadExports "github.com/golemcloud/golem/sdks/go/golem/internal/exports/export_golem_api_load_snapshot"
+	saveExports "github.com/golemcloud/golem/sdks/go/golem/internal/exports/export_golem_api_save_snapshot"
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+	apihost "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_host"
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// agentIDEnvVar is how the executor tells the guest which agent instance it is.
+const agentIDEnvVar = "GOLEM_AGENT_ID"
+
+// Stages a dispatch can panic in, so a recovered panic can be attributed to the
+// agent's code or to the SDK itself.
+const (
+	stageDecode  = "decoding input"
+	stageHandler = "agent method"
+	stageEncode  = "encoding output"
+)
+
+// PanicError is a recovered panic, attributed to the stage it occurred in.
+type PanicError struct {
+	Method string
+	Stage  string
+	Value  any
+}
+
+// Internal reports whether the panic came from SDK machinery (marshaling)
+// rather than from the agent's handler — i.e. whether it is our bug. An
+// [encodeError] is the agent supplying an unencodable value, so it is not
+// internal even though it surfaces in the encode stage.
+func (e *PanicError) Internal() bool {
+	if _, ok := e.Value.(*encodeError); ok {
+		return false
+	}
+	return e.Stage != stageHandler
+}
+
+func (e *PanicError) Error() string {
+	if ee, ok := e.Value.(*encodeError); ok {
+		return fmt.Sprintf("agent method %q returned a value that cannot be encoded: %s", e.Method, ee.Error())
+	}
+	if e.Internal() {
+		return fmt.Sprintf("INTERNAL SDK ERROR while %s for method %q: %v", e.Stage, e.Method, e.Value)
+	}
+	return fmt.Sprintf("agent method %q panicked: %v", e.Method, e.Value)
+}
+
+// Unwrap exposes the recovered value when it is itself an error, so a wrapped
+// cause (e.g. a RemoteCallError from a nested call, or an encodeError) stays
+// reachable via errors.As/Is.
+func (e *PanicError) Unwrap() error {
+	if err, ok := e.Value.(error); ok {
+		return err
+	}
+	return nil
+}
+
+// encodeError marks an encode-stage panic caused by the agent supplying a value
+// the wire cannot carry — a nil or unregistered variant case, an out-of-range
+// enum value, or a Secret used as a parameter/return. It is the agent's mistake,
+// so it is reported as an agent error rather than an INTERNAL SDK error.
+type encodeError struct{ msg string }
+
+func (e *encodeError) Error() string { return e.msg }
+
+// decodeError marks failures that really are the caller's bad input, so they can
+// be reported as invalid-input rather than a generic failure.
+type decodeError struct{ msg string }
+
+func (e *decodeError) Error() string { return e.msg }
+
+// customError builds agent-error's custom-error case carrying a string payload:
+// the right bucket for failures that are neither bad input nor an unknown
+// method (a panic is not "invalid input").
+func customError(msg string) common.AgentError {
+	return common.MakeAgentErrorCustomError(types.TypedSchemaValue{
+		Graph: types.SchemaGraph{
+			TypeNodes: []types.SchemaTypeNode{{Body: types.MakeSchemaTypeBodyStringType()}},
+			Root:      0,
+		},
+		Value: types.SchemaValueTree{
+			ValueNodes: []types.SchemaValueNode{types.MakeSchemaValueNodeStringValue(msg)},
+			Root:       0,
+		},
+	})
+}
+
+// toAgentError maps an SDK or handler error onto the right agent-error case.
+func toAgentError(err error) common.AgentError {
+	var de *decodeError
+	if errors.As(err, &de) {
+		return common.MakeAgentErrorInvalidInput(de.Error())
+	}
+	// Panics and errors returned deliberately by agent code are both
+	// "something went wrong", not malformed input.
+	return customError(err.Error())
+}
+
+func init() {
+	guestExports.Exports.Initialize = func(agentType string, input types.SchemaValueTree, _ common.Principal) witTypes.Result[witTypes.Unit, common.AgentError] {
+		// Route structured logging (slog, and via it the standard log package)
+		// through the host logging channel so it carries a real level + context.
+		// Build-tag-gated to the wasm target so native `go test` never links the
+		// host call (see loginstall_*.go).
+		installDefaultLogger()
+		if _, ds := defs.discover(); agentDefErrors(ds, agentType) != "" {
+			return witTypes.Err[witTypes.Unit](customError("agent definition errors:\n" + agentDefErrors(ds, agentType)))
+		}
+		e := defs.agents[agentType]
+		if e == nil {
+			return witTypes.Err[witTypes.Unit](common.MakeAgentErrorInvalidType("unknown agent type: " + agentType))
+		}
+		if active != nil {
+			return witTypes.Err[witTypes.Unit](customError("agent already initialized"))
+		}
+		idVal := reflect.New(e.idType).Elem()
+		if err := decodeParams(input, e.idFields, idVal); err != nil {
+			return witTypes.Err[witTypes.Unit](common.MakeAgentErrorInvalidInput(err.Error()))
+		}
+		// Publish the instance before running the constructor so a constructor that
+		// reads config (via ctx.Config()) populates the same per-worker config cache
+		// the methods use. The constructor sees only its InitContext, never the
+		// not-yet-built state, so the nil state during this window is unobservable.
+		agentID := os.Getenv(agentIDEnvVar)
+		inst := &instance{def: e, agentID: agentID}
+		active = inst
+		inst.state = e.newState(idVal, agentID)
+		return witTypes.Ok[witTypes.Unit, common.AgentError](witTypes.Unit{})
+	}
+
+	guestExports.Exports.Invoke = func(methodName string, input types.SchemaValueTree, _ common.Principal) witTypes.Result[witTypes.Option[types.SchemaValueTree], common.AgentError] {
+		fail := func(e common.AgentError) witTypes.Result[witTypes.Option[types.SchemaValueTree], common.AgentError] {
+			return witTypes.Err[witTypes.Option[types.SchemaValueTree]](e)
+		}
+		if active == nil {
+			return fail(common.MakeAgentErrorInvalidMethod("agent not initialized"))
+		}
+		m := active.def.methods[methodName]
+		if m == nil {
+			return fail(common.MakeAgentErrorInvalidMethod("unknown method: " + methodName))
+		}
+		out, err := m.invoke(active.state, active.agentID, input)
+		if err != nil {
+			return fail(toAgentError(err))
+		}
+		if out == nil {
+			return witTypes.Ok[witTypes.Option[types.SchemaValueTree], common.AgentError](
+				witTypes.None[types.SchemaValueTree]())
+		}
+		return witTypes.Ok[witTypes.Option[types.SchemaValueTree], common.AgentError](
+			witTypes.Some(*out))
+	}
+
+	// GetDefinition has no error channel in the WIT. It is only valid after a
+	// successful initialize, and initialize refuses an agent with definition
+	// errors — so by the time this runs the type is already validated.
+	guestExports.Exports.GetDefinition = func() common.AgentType {
+		types, _ := defs.discover()
+		want := ""
+		if active != nil {
+			want = active.def.name
+		} else if len(defs.order) > 0 {
+			want = defs.order[0]
+		}
+		for _, at := range types {
+			if at.TypeName == want {
+				return at
+			}
+		}
+		return common.AgentType{}
+	}
+
+	guestExports.Exports.DiscoverAgentTypes = func() witTypes.Result[[]common.AgentType, common.AgentError] {
+		types, ds := defs.discover()
+		if len(ds) > 0 {
+			return witTypes.Err[[]common.AgentType](customError(allDefErrors(ds)))
+		}
+		return witTypes.Ok[[]common.AgentType, common.AgentError](types)
+	}
+
+	// save/load-snapshot serialize and restore the running instance's state. save
+	// has no error channel in the WIT, so a failure there is fatal (panic); load
+	// reports failures through its result.
+	saveExports.Exports.Save = func() apihost.Snapshot {
+		if active == nil {
+			panic(fmt.Errorf("golem: save-snapshot before initialize"))
+		}
+		snap, err := saveState(active.state)
+		if err != nil {
+			panic(fmt.Errorf("golem: snapshot save failed: %w", err))
+		}
+		return snap
+	}
+
+	loadExports.Exports.Load = func(snap apihost.Snapshot) witTypes.Result[witTypes.Unit, string] {
+		if active == nil {
+			return witTypes.Err[witTypes.Unit]("agent not initialized")
+		}
+		if err := loadState(active.state, snap); err != nil {
+			return witTypes.Err[witTypes.Unit](err.Error())
+		}
+		return witTypes.Ok[witTypes.Unit, string](witTypes.Unit{})
+	}
+}
diff --git a/sdks/go/golem/http_mount.go b/sdks/go/golem/http_mount.go
new file mode 100644
index 0000000000..f06be8467b
--- /dev/null
+++ b/sdks/go/golem/http_mount.go
@@ -0,0 +1,595 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+	"unicode"
+
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// HTTP mounting is metadata only. The guest publishes an agent-level mount and
+// per-method endpoints; the platform compiles those into routes and, when a
+// request arrives, derives the agent id from the mount path variables and the
+// method arguments from the endpoint's path/query/header bindings (and body),
+// then calls the ordinary initialize/invoke exports. The guest never handles a
+// raw HTTP request — there is no incoming-handler to implement here.
+//
+// Go has no compile-time layer for route strings (unlike the TS SDK's template
+// literals), so every binding rule the TS type system enforces is checked at
+// registration and reported through the definition-error channel (see
+// definition.go) rather than surfacing as a runtime surprise.
+
+// Mount declares that an agent's methods are reachable over HTTP under a common
+// path prefix. Set it on [Spec.HTTP].
+//
+// The prefix's {var} segments bind the agent's constructor (Id) fields, so the
+// platform can tell which instance a request addresses — every Id field must
+// appear as a {var}. Segments may also be literals, the catch-all {*rest} (last
+// only), or the system tokens {agent-type} / {agent-version}.
+type Mount struct {
+	// Path is the mount prefix, e.g. "/counters/{name}". Required.
+	Path string
+	// Auth requires authentication on every endpoint (an endpoint may override).
+	Auth bool
+	// CORS is the list of allowed-origin patterns; empty means none.
+	CORS []string
+	// PhantomAgent provisions a fresh instance per request instead of routing to
+	// a persistent one.
+	PhantomAgent bool
+	// WebhookSuffix is an optional, literal-only path suffix advertised for
+	// webhooks.
+	WebhookSuffix string
+}
+
+// Endpoint is one HTTP route for a method: a verb plus a path suffix (appended
+// to the agent's mount prefix) and how request data binds to the method's input
+// fields. Build one with a verb constructor ([GET], [POST], …) and configure it
+// with [EndpointOpt]s; a method may have several via [HTTP].
+type Endpoint struct {
+	method    string
+	path      string
+	headers   []wireBind // wire header name -> input field
+	query     []wireBind // wire query name -> input field (in addition to inline ?k={f})
+	auth      *bool      // nil = inherit the mount; non-nil = override
+	authCount int        // how many times EndpointAuth was applied (>1 is a misuse)
+	cors      []string
+}
+
+// wireBind maps a wire name (a header or query-parameter name) to the input
+// field it fills.
+type wireBind struct{ wire, field string }
+
+// EndpointOpt configures an [Endpoint].
+type EndpointOpt func(*Endpoint)
+
+func newEndpoint(method, path string, opts []EndpointOpt) Endpoint {
+	e := Endpoint{method: method, path: path}
+	for _, o := range opts {
+		o(&e)
+	}
+	return e
+}
+
+// GET builds a GET endpoint; like the other verb constructors below it names an
+// HTTP method plus a path suffix. GET and HEAD are bodyless (they must bind
+// every input field, since there is no request body to carry the rest); the
+// other verbs carry unbound fields in the body.
+func GET(path string, opts ...EndpointOpt) Endpoint     { return newEndpoint("GET", path, opts) }
+func HEAD(path string, opts ...EndpointOpt) Endpoint    { return newEndpoint("HEAD", path, opts) }
+func POST(path string, opts ...EndpointOpt) Endpoint    { return newEndpoint("POST", path, opts) }
+func PUT(path string, opts ...EndpointOpt) Endpoint     { return newEndpoint("PUT", path, opts) }
+func DELETE(path string, opts ...EndpointOpt) Endpoint  { return newEndpoint("DELETE", path, opts) }
+func CONNECT(path string, opts ...EndpointOpt) Endpoint { return newEndpoint("CONNECT", path, opts) }
+func OPTIONS(path string, opts ...EndpointOpt) Endpoint { return newEndpoint("OPTIONS", path, opts) }
+func TRACE(path string, opts ...EndpointOpt) Endpoint   { return newEndpoint("TRACE", path, opts) }
+func PATCH(path string, opts ...EndpointOpt) Endpoint   { return newEndpoint("PATCH", path, opts) }
+
+// Custom builds an endpoint with a non-standard HTTP verb.
+func Custom(verb, path string, opts ...EndpointOpt) Endpoint { return newEndpoint(verb, path, opts) }
+
+// Header binds an incoming request header to an input field. wire is the header
+// name on the wire (e.g. "X-Tenant"); field is the method input field it fills.
+func Header(wire, field string) EndpointOpt {
+	return func(e *Endpoint) { e.headers = append(e.headers, wireBind{wire, field}) }
+}
+
+// Query binds a query parameter to an input field, for when the parameter name
+// differs from the field name (inline "?name={field}" in the path is equivalent
+// when they match).
+func Query(wire, field string) EndpointOpt {
+	return func(e *Endpoint) { e.query = append(e.query, wireBind{wire, field}) }
+}
+
+// EndpointAuth overrides the mount's auth requirement for this endpoint. Setting
+// it more than once on one endpoint is a definition error, not a silent
+// overwrite.
+func EndpointAuth(required bool) EndpointOpt {
+	return func(e *Endpoint) { e.auth = &required; e.authCount++ }
+}
+
+// EndpointCORS sets allowed-origin patterns for this endpoint.
+func EndpointCORS(patterns ...string) EndpointOpt {
+	return func(e *Endpoint) { e.cors = append(e.cors, patterns...) }
+}
+
+// ---------------------------------------------------------------------------
+// Path parsing (pure)
+// ---------------------------------------------------------------------------
+
+type segKind int
+
+const (
+	literalSeg segKind = iota
+	varSeg
+	restSeg
+	sysSeg
+)
+
+type pathSeg struct {
+	kind  segKind
+	value string // literal text, variable name, or system-token name
+}
+
+type parsedPath struct {
+	segs  []pathSeg
+	query []wireBind
+}
+
+// parsePath parses a path string into segments (and, when allowQuery, an inline
+// query string). It returns every problem it finds rather than stopping at the
+// first, so a bad route surfaces all its issues at once.
+func parsePath(path string, allowQuery bool) (parsedPath, []string) {
+	var out parsedPath
+	var errs []string
+	if path == "" {
+		return out, []string{"path must not be empty"}
+	}
+
+	rawPath := path
+	if i := strings.IndexByte(path, '?'); i >= 0 {
+		rawPath = path[:i]
+		if !allowQuery {
+			errs = append(errs, "query parameters are not allowed in a mount or webhook path")
+		} else {
+			out.query, errs = parseQuery(path[i+1:], errs)
+		}
+	}
+
+	if !strings.HasPrefix(rawPath, "/") {
+		return out, append(errs, "path must start with '/'")
+	}
+	body := rawPath[1:]
+	if body == "" {
+		return out, errs // just "/": no segments
+	}
+
+	for _, p := range strings.Split(body, "/") {
+		seg, serrs := parseSegment(p)
+		errs = append(errs, serrs...)
+		if seg != nil {
+			out.segs = append(out.segs, *seg)
+		}
+	}
+	for i, s := range out.segs {
+		if s.kind == restSeg && i != len(out.segs)-1 {
+			errs = append(errs, fmt.Sprintf("catch-all {*%s} must be the last path segment", s.value))
+		}
+	}
+	return out, errs
+}
+
+func parseSegment(p string) (*pathSeg, []string) {
+	switch {
+	case p == "":
+		return nil, []string{"empty path segment (check for '//' or a trailing '/')"}
+	case strings.ContainsAny(p, " \t"):
+		return nil, []string{fmt.Sprintf("path segment %q must not contain whitespace", p)}
+	case !strings.ContainsAny(p, "{}"):
+		return &pathSeg{kind: literalSeg, value: p}, nil
+	}
+	if !strings.HasPrefix(p, "{") || !strings.HasSuffix(p, "}") ||
+		strings.Count(p, "{") != 1 || strings.Count(p, "}") != 1 {
+		return nil, []string{fmt.Sprintf("path segment %q must be either a literal or a whole-segment {variable}", p)}
+	}
+	inner := p[1 : len(p)-1]
+	switch {
+	case inner == "":
+		return nil, []string{"empty {} variable"}
+	case inner == "agent-type" || inner == "agent-version":
+		return &pathSeg{kind: sysSeg, value: inner}, nil
+	case strings.HasPrefix(inner, "*"):
+		name := inner[1:]
+		if e := validVarName(name); e != "" {
+			return nil, []string{"catch-all " + e}
+		}
+		return &pathSeg{kind: restSeg, value: name}, nil
+	default:
+		if e := validVarName(inner); e != "" {
+			return nil, []string{e}
+		}
+		return &pathSeg{kind: varSeg, value: inner}, nil
+	}
+}
+
+func parseQuery(qs string, errs []string) ([]wireBind, []string) {
+	var out []wireBind
+	if qs == "" {
+		return out, append(errs, "empty query string after '?'")
+	}
+	for _, pair := range strings.Split(qs, "&") {
+		eq := strings.IndexByte(pair, '=')
+		if eq < 0 {
+			errs = append(errs, fmt.Sprintf("query %q must be of the form name={field}", pair))
+			continue
+		}
+		wire, val := pair[:eq], pair[eq+1:]
+		if wire == "" {
+			errs = append(errs, fmt.Sprintf("query %q has an empty parameter name", pair))
+			continue
+		}
+		if !strings.HasPrefix(val, "{") || !strings.HasSuffix(val, "}") {
+			errs = append(errs, fmt.Sprintf("query parameter %q value must be a {field} reference", wire))
+			continue
+		}
+		field := val[1 : len(val)-1]
+		if e := validVarName(field); e != "" {
+			errs = append(errs, e)
+			continue
+		}
+		out = append(out, wireBind{wire: wire, field: field})
+	}
+	return out, errs
+}
+
+func validVarName(n string) string {
+	if n == "" {
+		return "variable name must not be empty"
+	}
+	for _, r := range n {
+		if r != '_' && !unicode.IsLetter(r) && !unicode.IsDigit(r) {
+			return fmt.Sprintf("variable name %q has an invalid character %q", n, string(r))
+		}
+	}
+	return ""
+}
+
+func isBodyless(verb string) bool {
+	switch strings.ToUpper(verb) {
+	case "GET", "HEAD":
+		return true
+	}
+	return false
+}
+
+// bindableKind reports whether a field of this kind can be filled from a URL
+// path/query/header value — only scalars are string-decodable.
+func bindableKind(k reflect.Kind) bool {
+	switch k {
+	case reflect.String, reflect.Bool,
+		reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
+		reflect.Float32, reflect.Float64:
+		return true
+	}
+	return false
+}
+
+// ---------------------------------------------------------------------------
+// Validate + compile to WIT
+// ---------------------------------------------------------------------------
+
+// buildHTTP validates an agent's mount and endpoints and compiles them to the
+// WIT metadata reported at discovery. Every problem is returned as an attributed
+// definition error rather than panicking; the compiled records are still
+// returned so a well-formed part of a partly-broken component still publishes
+// (discovery gates on the errors, so nothing invalid actually deploys).
+func buildHTTP(e *agentEntry) (witTypes.Option[common.HttpMountDetails], map[string][]common.HttpEndpointDetails, []definitionError) {
+	var errs []definitionError
+	rec := func(method, format string, args ...any) {
+		errs = append(errs, definitionError{agent: e.name, method: method, detail: fmt.Sprintf(format, args...)})
+	}
+
+	if e.mount == nil {
+		for _, name := range e.order {
+			if len(e.methods[name].endpoints) > 0 {
+				rec(name, "declares HTTP endpoint(s) but the agent has no HTTP mount; set Spec.HTTP")
+			}
+		}
+		return witTypes.None[common.HttpMountDetails](), nil, errs
+	}
+
+	mp, perrs := parsePath(e.mount.Path, false)
+	for _, pe := range perrs {
+		rec("", "HTTP mount path %q: %s", e.mount.Path, pe)
+	}
+
+	idNames := fieldNameSet(e.idFields)
+	mountVars := map[string]bool{}
+	for _, s := range mp.segs {
+		if s.kind == varSeg || s.kind == restSeg {
+			mountVars[s.value] = true
+			if !idNames[s.value] {
+				rec("", "HTTP mount path variable {%s} is not a constructor (Id) field", s.value)
+			}
+		}
+	}
+	for _, f := range e.idFields {
+		if !mountVars[f.name] {
+			rec("", "HTTP mount path does not bind Id field %q; every constructor field must appear as a {var}", f.name)
+		}
+	}
+
+	webhook := []common.PathSegment{}
+	if e.mount.WebhookSuffix != "" {
+		wp, werrs := parsePath(e.mount.WebhookSuffix, false)
+		for _, we := range werrs {
+			rec("", "HTTP webhook suffix %q: %s", e.mount.WebhookSuffix, we)
+		}
+		for _, s := range wp.segs {
+			if s.kind != literalSeg {
+				rec("", "HTTP webhook suffix must contain only literal segments, got {%s}", s.value)
+			}
+		}
+		webhook = witSegments(wp.segs)
+	}
+
+	mount := common.HttpMountDetails{
+		PathPrefix:    witSegments(mp.segs),
+		AuthDetails:   witTypes.Some(common.AuthDetails{Required: e.mount.Auth}),
+		PhantomAgent:  e.mount.PhantomAgent,
+		CorsOptions:   common.CorsOptions{AllowedPatterns: e.mount.CORS},
+		WebhookSuffix: webhook,
+	}
+
+	endpoints := map[string][]common.HttpEndpointDetails{}
+	for _, name := range e.order {
+		m := e.methods[name]
+		inNames := fieldNameSet(m.inFields)
+		inKind := fieldKindMap(m.inFields)
+		for _, ep := range m.endpoints {
+			det, eerrs := validateAndCompileEndpoint(ep, inNames, inKind, mountVars)
+			for _, ee := range eerrs {
+				rec(name, "%s", ee)
+			}
+			endpoints[name] = append(endpoints[name], det)
+		}
+	}
+
+	return witTypes.Some(mount), endpoints, errs
+}
+
+func validateAndCompileEndpoint(ep Endpoint, inNames map[string]bool, inKind map[string]reflect.Kind, mountVars map[string]bool) (common.HttpEndpointDetails, []string) {
+	var errs []string
+	if ep.authCount > 1 {
+		errs = append(errs, fmt.Sprintf("%s %q: EndpointAuth set %d times (an endpoint has one auth setting)", ep.method, ep.path, ep.authCount))
+	}
+	pp, perrs := parsePath(ep.path, true)
+	for _, pe := range perrs {
+		errs = append(errs, fmt.Sprintf("%s %q: %s", ep.method, ep.path, pe))
+	}
+
+	bound := map[string]int{}
+	bind := func(field, where string) {
+		if !inNames[field] && !mountVars[field] {
+			errs = append(errs, fmt.Sprintf("%s variable {%s} is not an input field of the method (nor a mount variable)", where, field))
+			return
+		}
+		if inNames[field] {
+			if k, ok := inKind[field]; ok && !bindableKind(k) {
+				errs = append(errs, fmt.Sprintf("%s cannot bind input field %q (kind %s); only scalar fields decode from a URL", where, field, k))
+			}
+		}
+		bound[field]++
+	}
+
+	for _, s := range pp.segs {
+		if s.kind == varSeg || s.kind == restSeg {
+			bind(s.value, "path")
+		}
+	}
+	queryWire := map[string]bool{}
+	addQuery := func(qs []wireBind) {
+		for _, q := range qs {
+			if queryWire[q.wire] {
+				errs = append(errs, fmt.Sprintf("duplicate query parameter %q", q.wire))
+			}
+			queryWire[q.wire] = true
+			bind(q.field, "query")
+		}
+	}
+	addQuery(pp.query)
+	addQuery(ep.query)
+
+	headerWire := map[string]bool{}
+	for _, h := range ep.headers {
+		lw := strings.ToLower(h.wire)
+		if headerWire[lw] {
+			errs = append(errs, fmt.Sprintf("duplicate header %q", h.wire))
+		}
+		headerWire[lw] = true
+		bind(h.field, "header")
+	}
+
+	for _, f := range sortedKeys(bound) {
+		if bound[f] > 1 {
+			errs = append(errs, fmt.Sprintf("input field %q is bound %d times; bind it from exactly one of path/query/header", f, bound[f]))
+		}
+	}
+
+	if isBodyless(ep.method) {
+		for _, f := range sortedKeys(inNames) {
+			if bound[f] == 0 {
+				errs = append(errs, fmt.Sprintf("%s endpoint must bind every input field, but %q is unbound (a bodyless verb carries no request body)", ep.method, f))
+			}
+		}
+	}
+
+	queryVars := make([]common.QueryVariable, 0, len(pp.query)+len(ep.query))
+	for _, q := range pp.query {
+		queryVars = append(queryVars, common.QueryVariable{QueryParamName: q.wire, VariableName: q.field})
+	}
+	for _, q := range ep.query {
+		queryVars = append(queryVars, common.QueryVariable{QueryParamName: q.wire, VariableName: q.field})
+	}
+	headerVars := make([]common.HeaderVariable, 0, len(ep.headers))
+	for _, h := range ep.headers {
+		headerVars = append(headerVars, common.HeaderVariable{HeaderName: h.wire, VariableName: h.field})
+	}
+	auth := witTypes.None[common.AuthDetails]()
+	if ep.auth != nil {
+		auth = witTypes.Some(common.AuthDetails{Required: *ep.auth})
+	}
+
+	det := common.HttpEndpointDetails{
+		HttpMethod:  witMethod(ep.method),
+		PathSuffix:  witSegments(pp.segs),
+		HeaderVars:  headerVars,
+		QueryVars:   queryVars,
+		AuthDetails: auth,
+		CorsOptions: common.CorsOptions{AllowedPatterns: ep.cors},
+	}
+	return det, errs
+}
+
+func witSegments(segs []pathSeg) []common.PathSegment {
+	out := make([]common.PathSegment, 0, len(segs))
+	for _, s := range segs {
+		switch s.kind {
+		case literalSeg:
+			out = append(out, common.MakePathSegmentLiteral(s.value))
+		case varSeg:
+			out = append(out, common.MakePathSegmentPathVariable(common.PathVariable{VariableName: s.value}))
+		case restSeg:
+			out = append(out, common.MakePathSegmentRemainingPathVariable(common.PathVariable{VariableName: s.value}))
+		case sysSeg:
+			sv := common.SystemVariableAgentType
+			if s.value == "agent-version" {
+				sv = common.SystemVariableAgentVersion
+			}
+			out = append(out, common.MakePathSegmentSystemVariable(sv))
+		}
+	}
+	return out
+}
+
+func witMethod(verb string) common.HttpMethod {
+	switch strings.ToUpper(verb) {
+	case "GET":
+		return common.MakeHttpMethodGet()
+	case "HEAD":
+		return common.MakeHttpMethodHead()
+	case "POST":
+		return common.MakeHttpMethodPost()
+	case "PUT":
+		return common.MakeHttpMethodPut()
+	case "DELETE":
+		return common.MakeHttpMethodDelete()
+	case "CONNECT":
+		return common.MakeHttpMethodConnect()
+	case "OPTIONS":
+		return common.MakeHttpMethodOptions()
+	case "TRACE":
+		return common.MakeHttpMethodTrace()
+	case "PATCH":
+		return common.MakeHttpMethodPatch()
+	default:
+		return common.MakeHttpMethodCustom(verb)
+	}
+}
+
+// routeKey renders a verb plus the full path (mount prefix ++ endpoint suffix)
+// into a normalized string for collision detection. Variable names are erased,
+// because the gateway matches on position — so GET /a/{x} and GET /a/{y} are the
+// same route and must not both be declared.
+func routeKey(method common.HttpMethod, prefix, suffix []common.PathSegment) string {
+	var b strings.Builder
+	b.WriteString(verbName(method))
+	for _, group := range [][]common.PathSegment{prefix, suffix} {
+		for _, s := range group {
+			b.WriteByte('/')
+			switch s.Tag() {
+			case common.PathSegmentLiteral:
+				b.WriteString(s.Literal())
+			case common.PathSegmentPathVariable:
+				b.WriteString("{}")
+			case common.PathSegmentRemainingPathVariable:
+				b.WriteString("{*}")
+			case common.PathSegmentSystemVariable:
+				if s.SystemVariable() == common.SystemVariableAgentVersion {
+					b.WriteString("{agent-version}")
+				} else {
+					b.WriteString("{agent-type}")
+				}
+			}
+		}
+	}
+	return b.String()
+}
+
+func verbName(m common.HttpMethod) string {
+	switch m.Tag() {
+	case common.HttpMethodGet:
+		return "GET"
+	case common.HttpMethodHead:
+		return "HEAD"
+	case common.HttpMethodPost:
+		return "POST"
+	case common.HttpMethodPut:
+		return "PUT"
+	case common.HttpMethodDelete:
+		return "DELETE"
+	case common.HttpMethodConnect:
+		return "CONNECT"
+	case common.HttpMethodOptions:
+		return "OPTIONS"
+	case common.HttpMethodTrace:
+		return "TRACE"
+	case common.HttpMethodPatch:
+		return "PATCH"
+	default:
+		return m.Custom()
+	}
+}
+
+func fieldNameSet(fs []fieldInfo) map[string]bool {
+	m := make(map[string]bool, len(fs))
+	for _, f := range fs {
+		m[f.name] = true
+	}
+	return m
+}
+
+func fieldKindMap(fs []fieldInfo) map[string]reflect.Kind {
+	m := make(map[string]reflect.Kind, len(fs))
+	for _, f := range fs {
+		m[f.name] = f.typ.Kind()
+	}
+	return m
+}
+
+func sortedKeys[V any](m map[string]V) []string {
+	out := make([]string, 0, len(m))
+	for k := range m {
+		out = append(out, k)
+	}
+	sort.Strings(out)
+	return out
+}
diff --git a/sdks/go/golem/http_mount_test.go b/sdks/go/golem/http_mount_test.go
new file mode 100644
index 0000000000..8a1252fbe0
--- /dev/null
+++ b/sdks/go/golem/http_mount_test.go
@@ -0,0 +1,361 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+)
+
+// ---------------------------------------------------------------------------
+// path parser
+// ---------------------------------------------------------------------------
+
+func TestParsePathValid(t *testing.T) {
+	cases := []struct {
+		path      string
+		allowQ    bool
+		wantSegs  string // rendered form
+		wantQuery string // "wire=field,wire=field" or ""
+	}{
+		{"/counters/{name}", false, "counters,{name}", ""},
+		{"/", false, "", ""},
+		{"/files/{*rest}", false, "files,{*rest}", ""},
+		{"/{agent-type}/{name}", false, "{sys:agent-type},{name}", ""},
+		{"/{agent-version}", false, "{sys:agent-version}", ""},
+		{"/add?by={by}", true, "add", "by=by"},
+		{"/search?q={query}&n={limit}", true, "search", "q=query,n=limit"},
+	}
+	for _, c := range cases {
+		pp, errs := parsePath(c.path, c.allowQ)
+		if len(errs) != 0 {
+			t.Errorf("%q: unexpected errors %v", c.path, errs)
+			continue
+		}
+		if got := renderSegs2(pp.segs); got != c.wantSegs {
+			t.Errorf("%q: segs = %q, want %q", c.path, got, c.wantSegs)
+		}
+		if got := renderQuery(pp.query); got != c.wantQuery {
+			t.Errorf("%q: query = %q, want %q", c.path, got, c.wantQuery)
+		}
+	}
+}
+
+func TestParsePathErrors(t *testing.T) {
+	cases := []struct {
+		path   string
+		allowQ bool
+		want   string
+	}{
+		{"counters/{name}", false, "must start with '/'"},
+		{"/a//b", false, "empty path segment"},
+		{"/a/ b", false, "must not contain whitespace"},
+		{"/a{b}", false, "whole-segment"},
+		{"/{*rest}/more", false, "must be the last"},
+		{"/x?y={z}", false, "query parameters are not allowed"},
+		{"/x?bad", true, "must be of the form name={field}"},
+		{"/x?a=notref", true, "must be a {field} reference"},
+		{"/x?={y}", true, "empty parameter name"},
+		{"", false, "must not be empty"},
+		{"/{a-b}", false, "invalid character"},
+		{"/{*}", false, "must not be empty"},
+		{"/{}", false, "empty {} variable"},
+	}
+	for _, c := range cases {
+		_, errs := parsePath(c.path, c.allowQ)
+		if !containsSubstr(errs, c.want) {
+			t.Errorf("%q: errors %v, want one mentioning %q", c.path, errs, c.want)
+		}
+	}
+}
+
+// ---------------------------------------------------------------------------
+// buildHTTP: full mapping + every validation
+// ---------------------------------------------------------------------------
+
+func TestBuildHTTPCompilesAFullMountAndEndpoints(t *testing.T) {
+	e := agent("CounterAgent",
+		&Mount{Path: "/counters/{name}", Auth: true, CORS: []string{"*"}, PhantomAgent: true, WebhookSuffix: "/events"},
+		fields("name"),
+		method("add", fields("by", "tenant"),
+			POST("/add?by={by}", Header("X-Tenant", "tenant"), EndpointAuth(false), EndpointCORS("https://x")),
+			GET("/add/{by}", Query("t", "tenant")),
+		),
+		method("value", nil, GET("/value")),
+	)
+
+	mount, endpoints, errs := buildHTTP(e)
+	if len(errs) != 0 {
+		t.Fatalf("unexpected definition errors: %v", errs)
+	}
+	if !mount.IsSome() {
+		t.Fatal("expected a mount")
+	}
+	m := mount.Some()
+	if got := renderSegs(m.PathPrefix); got != "/counters/{name}" {
+		t.Errorf("mount prefix = %q", got)
+	}
+	if !m.AuthDetails.IsSome() || !m.AuthDetails.Some().Required {
+		t.Errorf("mount auth not required")
+	}
+	if !m.PhantomAgent {
+		t.Errorf("phantom agent not set")
+	}
+	if got := renderSegs(m.WebhookSuffix); got != "/events" {
+		t.Errorf("webhook suffix = %q", got)
+	}
+	if len(m.CorsOptions.AllowedPatterns) != 1 || m.CorsOptions.AllowedPatterns[0] != "*" {
+		t.Errorf("mount cors = %v", m.CorsOptions.AllowedPatterns)
+	}
+
+	add := endpoints["add"]
+	if len(add) != 2 {
+		t.Fatalf("add: want 2 endpoints, got %d", len(add))
+	}
+	// endpoint 0: POST /add?by={by} with X-Tenant header, auth override false
+	if add[0].HttpMethod.Tag() != common.HttpMethodPost {
+		t.Errorf("add[0] method tag = %d", add[0].HttpMethod.Tag())
+	}
+	if got := renderSegs(add[0].PathSuffix); got != "/add" {
+		t.Errorf("add[0] suffix = %q", got)
+	}
+	if len(add[0].QueryVars) != 1 || add[0].QueryVars[0].QueryParamName != "by" || add[0].QueryVars[0].VariableName != "by" {
+		t.Errorf("add[0] query = %v", add[0].QueryVars)
+	}
+	if len(add[0].HeaderVars) != 1 || add[0].HeaderVars[0].HeaderName != "X-Tenant" || add[0].HeaderVars[0].VariableName != "tenant" {
+		t.Errorf("add[0] headers = %v", add[0].HeaderVars)
+	}
+	if !add[0].AuthDetails.IsSome() || add[0].AuthDetails.Some().Required {
+		t.Errorf("add[0] auth override should be Some(false)")
+	}
+	// endpoint 1: GET /add/{by}?t={tenant} — bodyless, binds by (path) + tenant (query)
+	if got := renderSegs(add[1].PathSuffix); got != "/add/{by}" {
+		t.Errorf("add[1] suffix = %q", got)
+	}
+	if len(add[1].QueryVars) != 1 || add[1].QueryVars[0].QueryParamName != "t" {
+		t.Errorf("add[1] query = %v", add[1].QueryVars)
+	}
+	if add[1].AuthDetails.IsSome() {
+		t.Errorf("add[1] auth should inherit (None)")
+	}
+}
+
+func TestBuildHTTPCustomVerb(t *testing.T) {
+	e := agent("A", &Mount{Path: "/a/{id}"}, fields("id"),
+		method("report", nil, Custom("REPORT", "/report")))
+	_, endpoints, errs := buildHTTP(e)
+	if len(errs) != 0 {
+		t.Fatalf("errs: %v", errs)
+	}
+	m := endpoints["report"][0].HttpMethod
+	if m.Tag() != common.HttpMethodCustom || m.Custom() != "REPORT" {
+		t.Errorf("verb = tag %d %q", m.Tag(), m.Custom())
+	}
+}
+
+func TestVerbConstructorsMapToWit(t *testing.T) {
+	cases := []struct {
+		ep  Endpoint
+		tag uint8
+	}{
+		{GET("/x"), common.HttpMethodGet},
+		{HEAD("/x"), common.HttpMethodHead},
+		{POST("/x"), common.HttpMethodPost},
+		{PUT("/x"), common.HttpMethodPut},
+		{DELETE("/x"), common.HttpMethodDelete},
+		{CONNECT("/x"), common.HttpMethodConnect},
+		{OPTIONS("/x"), common.HttpMethodOptions},
+		{TRACE("/x"), common.HttpMethodTrace},
+		{PATCH("/x"), common.HttpMethodPatch},
+	}
+	for _, c := range cases {
+		if got := witMethod(c.ep.method).Tag(); got != c.tag {
+			t.Errorf("%s -> tag %d, want %d", c.ep.method, got, c.tag)
+		}
+	}
+}
+
+// TestBuildHTTPSystemVarAndCatchAllSegments — System-variable and catch-all segments compile on both the mount prefix and an
+// endpoint suffix.
+func TestBuildHTTPSystemVarAndCatchAllSegments(t *testing.T) {
+	e := agent("A", &Mount{Path: "/{agent-type}/{id}"}, fields("id"),
+		method("m", fields("rest"), GET("/files/{*rest}")))
+	mount, endpoints, errs := buildHTTP(e)
+	if len(errs) != 0 {
+		t.Fatalf("errs: %v", errs)
+	}
+	if got := renderSegs(mount.Some().PathPrefix); got != "/{agent-type}/{id}" {
+		t.Errorf("prefix = %q", got)
+	}
+	if got := renderSegs(endpoints["m"][0].PathSuffix); got != "/files/{*rest}" {
+		t.Errorf("suffix = %q", got)
+	}
+}
+
+func TestBuildHTTPValidations(t *testing.T) {
+	cases := []struct {
+		name string
+		e    *agentEntry
+		want string
+	}{
+		{
+			"mount var not an id field",
+			agent("A", &Mount{Path: "/a/{tenant}"}, fields("id")),
+			"{tenant} is not a constructor",
+		},
+		{
+			"mount does not cover id",
+			agent("A", &Mount{Path: "/a/{id}"}, fields("id", "region")),
+			`does not bind Id field "region"`,
+		},
+		{
+			"endpoints without a mount",
+			agent("A", nil, fields("id"), method("m", nil, GET("/m"))),
+			"no HTTP mount",
+		},
+		{
+			"endpoint var not an input field",
+			agent("A", &Mount{Path: "/a/{id}"}, fields("id"), method("m", fields("x"), POST("/m/{y}"))),
+			"{y} is not an input field",
+		},
+		{
+			"bodyless must bind every field",
+			agent("A", &Mount{Path: "/a/{id}"}, fields("id"), method("m", fields("page", "size"), GET("/m?p={page}"))),
+			`"size" is unbound`,
+		},
+		{
+			"duplicate binding",
+			agent("A", &Mount{Path: "/a/{id}"}, fields("id"), method("m", fields("x"), POST("/m/{x}?x={x}"))),
+			`"x" is bound 2 times`,
+		},
+		{
+			"non-scalar field not bindable",
+			agent("A", &Mount{Path: "/a/{id}"}, fields("id"),
+				method("m", []fieldInfo{{name: "blob", typ: reflect.TypeFor[[]byte]()}}, GET("/m/{blob}"))),
+			"only scalar fields",
+		},
+		{
+			"webhook suffix must be literal",
+			agent("A", &Mount{Path: "/a/{id}", WebhookSuffix: "/{oops}"}, fields("id")),
+			"only literal segments",
+		},
+		{
+			"duplicate query wire name",
+			agent("A", &Mount{Path: "/a/{id}"}, fields("id"), method("m", fields("x", "y"), POST("/m?k={x}", Query("k", "y")))),
+			`duplicate query parameter "k"`,
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			_, _, errs := buildHTTP(c.e)
+			if !containsDefErr(errs, c.want) {
+				t.Errorf("errors %v, want one mentioning %q", errs, c.want)
+			}
+		})
+	}
+}
+
+// ---------------------------------------------------------------------------
+// helpers
+// ---------------------------------------------------------------------------
+
+func fields(names ...string) []fieldInfo {
+	out := make([]fieldInfo, len(names))
+	for i, n := range names {
+		out[i] = fieldInfo{name: n, typ: reflect.TypeFor[string]()}
+	}
+	return out
+}
+
+func method(name string, in []fieldInfo, eps ...Endpoint) *methodEntry {
+	return &methodEntry{name: name, inFields: in, endpoints: eps}
+}
+
+func agent(name string, mount *Mount, idFields []fieldInfo, methods ...*methodEntry) *agentEntry {
+	e := &agentEntry{name: name, mount: mount, idFields: idFields, methods: map[string]*methodEntry{}}
+	for _, m := range methods {
+		e.methods[m.name] = m
+		e.order = append(e.order, m.name)
+	}
+	return e
+}
+
+func renderSegs(segs []common.PathSegment) string {
+	var parts []string
+	for _, s := range segs {
+		switch s.Tag() {
+		case common.PathSegmentLiteral:
+			parts = append(parts, s.Literal())
+		case common.PathSegmentPathVariable:
+			parts = append(parts, "{"+s.PathVariable().VariableName+"}")
+		case common.PathSegmentRemainingPathVariable:
+			parts = append(parts, "{*"+s.RemainingPathVariable().VariableName+"}")
+		case common.PathSegmentSystemVariable:
+			if s.SystemVariable() == common.SystemVariableAgentVersion {
+				parts = append(parts, "{agent-version}")
+			} else {
+				parts = append(parts, "{agent-type}")
+			}
+		}
+	}
+	return "/" + strings.Join(parts, "/")
+}
+
+// renderSegs2 renders parsed (pre-WIT) segments for parser tests.
+func renderSegs2(segs []pathSeg) string {
+	var parts []string
+	for _, s := range segs {
+		switch s.kind {
+		case literalSeg:
+			parts = append(parts, s.value)
+		case varSeg:
+			parts = append(parts, "{"+s.value+"}")
+		case restSeg:
+			parts = append(parts, "{*"+s.value+"}")
+		case sysSeg:
+			parts = append(parts, "{sys:"+s.value+"}")
+		}
+	}
+	return strings.Join(parts, ",")
+}
+
+func renderQuery(q []wireBind) string {
+	var parts []string
+	for _, b := range q {
+		parts = append(parts, b.wire+"="+b.field)
+	}
+	return strings.Join(parts, ",")
+}
+
+func containsSubstr(errs []string, want string) bool {
+	for _, e := range errs {
+		if strings.Contains(e, want) {
+			return true
+		}
+	}
+	return false
+}
+
+func containsDefErr(errs []definitionError, want string) bool {
+	for _, e := range errs {
+		if strings.Contains(e.Error(), want) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/sdks/go/golem/http_test.go b/sdks/go/golem/http_test.go
new file mode 100644
index 0000000000..f50c87a906
--- /dev/null
+++ b/sdks/go/golem/http_test.go
@@ -0,0 +1,114 @@
+package golem
+
+import (
+	"net/http"
+	"testing"
+	"time"
+
+	httptypes "github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_http_0_3_0_types"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+func TestTimeoutFromDeadline(t *testing.T) {
+	now := time.Unix(1000, 0)
+
+	if nanos, ok := timeoutFromDeadline(now.Add(2*time.Second), now); !ok || nanos != uint64(2*time.Second) {
+		t.Fatalf("future deadline: got (%d, %v), want (%d, true)", nanos, ok, uint64(2*time.Second))
+	}
+	if _, ok := timeoutFromDeadline(now, now); ok {
+		t.Fatal("deadline == now should yield no budget")
+	}
+	if _, ok := timeoutFromDeadline(now.Add(-time.Second), now); ok {
+		t.Fatal("past deadline should yield no budget")
+	}
+}
+
+func TestErrorCodeStringCoversFamilies(t *testing.T) {
+	cases := map[httptypes.ErrorCode]string{
+		httptypes.MakeErrorCodeConnectionRefused():                    "connection refused",
+		httptypes.MakeErrorCodeConnectionTimeout():                    "connection timeout",
+		httptypes.MakeErrorCodeTlsCertificateError():                  "TLS certificate error",
+		httptypes.MakeErrorCodeHttpProtocolError():                    "HTTP protocol error",
+		httptypes.MakeErrorCodeDnsTimeout():                           "DNS timeout",
+		httptypes.MakeErrorCodeInternalError(witTypes.None[string]()): "internal error",
+	}
+	for code, want := range cases {
+		if got := errorCodeString(code); got != want {
+			t.Errorf("errorCodeString(tag %d) = %q, want %q", code.Tag(), got, want)
+		}
+	}
+}
+
+// TestMethodOf — methodOf maps an HTTP method string onto the wasi method variant, defaulting a
+// blank method to GET and passing anything unknown through as other(name).
+func TestMethodOf(t *testing.T) {
+	known := map[string]httptypes.Method{
+		"":        httptypes.MakeMethodGet(),
+		"get":     httptypes.MakeMethodGet(),
+		"GET":     httptypes.MakeMethodGet(),
+		"head":    httptypes.MakeMethodHead(),
+		"POST":    httptypes.MakeMethodPost(),
+		"put":     httptypes.MakeMethodPut(),
+		"DELETE":  httptypes.MakeMethodDelete(),
+		"connect": httptypes.MakeMethodConnect(),
+		"OPTIONS": httptypes.MakeMethodOptions(),
+		"trace":   httptypes.MakeMethodTrace(),
+		"PATCH":   httptypes.MakeMethodPatch(),
+	}
+	for in, want := range known {
+		if got := methodOf(in); got.Tag() != want.Tag() {
+			t.Errorf("methodOf(%q) tag = %d, want %d", in, got.Tag(), want.Tag())
+		}
+	}
+
+	// An unknown method is preserved verbatim as other(name).
+	other := methodOf("PROPFIND")
+	if other.Tag() != httptypes.MakeMethodOther("PROPFIND").Tag() || other.Other() != "PROPFIND" {
+		t.Errorf("methodOf(PROPFIND) = tag %d / %q, want other(PROPFIND)", other.Tag(), other.Other())
+	}
+}
+
+// TestSchemeOf — schemeOf maps a URL scheme onto the wasi scheme variant; a blank scheme
+// defaults to https and anything unknown passes through as other(name).
+func TestSchemeOf(t *testing.T) {
+	if got := schemeOf("http"); got.Tag() != httptypes.MakeSchemeHttp().Tag() {
+		t.Errorf("schemeOf(http) tag = %d, want http", got.Tag())
+	}
+	for _, in := range []string{"https", "HTTPS", ""} {
+		if got := schemeOf(in); got.Tag() != httptypes.MakeSchemeHttps().Tag() {
+			t.Errorf("schemeOf(%q) tag = %d, want https", in, got.Tag())
+		}
+	}
+	other := schemeOf("ftp")
+	if other.Tag() != httptypes.MakeSchemeOther("ftp").Tag() || other.Other() != "ftp" {
+		t.Errorf("schemeOf(ftp) = tag %d / %q, want other(ftp)", other.Tag(), other.Other())
+	}
+}
+
+// TestContentLength — contentLength reads the Content-Length header, returning -1 (unknown) when it
+// is absent or unparseable.
+func TestContentLength(t *testing.T) {
+	if got := contentLength(http.Header{}); got != -1 {
+		t.Errorf("missing Content-Length = %d, want -1", got)
+	}
+	if got := contentLength(http.Header{"Content-Length": {"42"}}); got != 42 {
+		t.Errorf("Content-Length 42 = %d, want 42", got)
+	}
+	if got := contentLength(http.Header{"Content-Length": {"nope"}}); got != -1 {
+		t.Errorf("unparseable Content-Length = %d, want -1", got)
+	}
+}
+
+// TestHeaderErr — headerErr renders each wasi header-error case to a readable string.
+func TestHeaderErr(t *testing.T) {
+	cases := map[httptypes.HeaderError]string{
+		httptypes.MakeHeaderErrorInvalidSyntax(): "invalid syntax",
+		httptypes.MakeHeaderErrorForbidden():     "forbidden",
+		httptypes.MakeHeaderErrorImmutable():     "immutable",
+	}
+	for e, want := range cases {
+		if got := headerErr(e); got != want {
+			t.Errorf("headerErr(tag %d) = %q, want %q", e.Tag(), got, want)
+		}
+	}
+}
diff --git a/sdks/go/golem/http_transport.go b/sdks/go/golem/http_transport.go
new file mode 100644
index 0000000000..8cab86ef37
--- /dev/null
+++ b/sdks/go/golem/http_transport.go
@@ -0,0 +1,351 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	httpclient "github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_http_0_3_0_client"
+	httptypes "github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_http_0_3_0_types"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// Outgoing HTTP.
+//
+// On this target Go's default transport is inert: wasip1 has no sockets, so
+// net.Dial never connects. This RoundTripper routes net/http through
+// wasi:http/client@0.3.0 instead, and the SDK installs it as
+// http.DefaultTransport in init() — so http.Get, http.DefaultClient, and any
+// library built on them work with no wiring from the user.
+//
+// Durability (idempotency keys, retries, trace propagation, accounting) is the
+// host's responsibility; this transport only marshals request/response.
+//
+// Not supported: anything that bypasses the transport and opens a raw socket —
+// net.Dial, most SQL drivers, custom gRPC transports. Those cannot work in a
+// component; use the SDK's typed host wrappers instead.
+
+// Transport is an http.RoundTripper backed by wasi:http/client@0.3.0.
+// The zero value is ready to use; the SDK installs one as http.DefaultTransport.
+type Transport struct{}
+
+// RoundTrip implements http.RoundTripper.
+//
+// Timeouts: set one with a request context deadline —
+// http.NewRequestWithContext(context.WithTimeout(...)). That deadline is
+// translated into wasi:http request-options and enforced by the host. Note that
+// http.Client.Timeout does NOT work here: the stdlib enforces it from a client
+// side timer goroutine, which can't preempt the blocking host Send on this
+// single-threaded target, and it never stamps req.Context().Deadline() for the
+// transport to read. Use a context deadline instead.
+func (Transport) RoundTrip(req *http.Request) (*http.Response, error) {
+	// A context deadline (or an already-cancelled context) lands on req; honor a
+	// cancellation before doing any work.
+	if err := req.Context().Err(); err != nil {
+		return nil, err
+	}
+
+	headers := httptypes.MakeFields()
+	for name, values := range req.Header {
+		for _, v := range values {
+			if r := headers.Append(name, []byte(v)); r.IsErr() {
+				return nil, fmt.Errorf("golem/http: invalid header %q: %v", name, headerErr(r.Err()))
+			}
+		}
+	}
+	// Host expects a Host header via the authority; don't duplicate it here.
+	headers.GetAndDelete("Host")
+
+	contents := requestBody(req)
+
+	// No request trailers. The future write blocks until the host consumes it,
+	// and only the blocking Send below drives the event loop — so resolve it
+	// from a goroutine, exactly like the request body stream.
+	trailersW, trailersR := httptypes.MakeFutureResultOptionFieldsErrorCode()
+	go trailersW.Write(witTypes.Ok[witTypes.Option[*httptypes.Fields], httptypes.ErrorCode](
+		witTypes.None[*httptypes.Fields]()))
+
+	// Translate the request's context deadline into wasi:http request-options.
+	// One budget bounds each transport phase.
+	options := witTypes.None[*httptypes.RequestOptions]()
+	if dl, ok := req.Context().Deadline(); ok {
+		if nanos, set := timeoutFromDeadline(dl, time.Now()); set {
+			o := httptypes.MakeRequestOptions()
+			o.SetConnectTimeout(witTypes.Some(nanos))
+			o.SetFirstByteTimeout(witTypes.Some(nanos))
+			o.SetBetweenBytesTimeout(witTypes.Some(nanos))
+			options = witTypes.Some(o)
+		}
+	}
+
+	request, _ := httptypes.RequestNew(
+		headers,
+		contents,
+		trailersR,
+		options,
+	)
+
+	request.SetMethod(methodOf(req.Method))
+	if req.URL != nil {
+		request.SetScheme(witTypes.Some(schemeOf(req.URL.Scheme)))
+		if req.URL.Host != "" {
+			request.SetAuthority(witTypes.Some(req.URL.Host))
+		}
+		request.SetPathWithQuery(witTypes.Some(req.URL.RequestURI()))
+	}
+
+	// Blocking from Go's view; a goroutine writing the request body yields to
+	// the component-model event loop while the host drains the stream.
+	res := httpclient.Send(request)
+	if res.IsErr() {
+		return nil, fmt.Errorf("golem/http: %s %s: %s", req.Method, req.URL, errorCodeString(res.Err()))
+	}
+	resp := res.Ok()
+
+	header := http.Header{}
+	for _, kv := range resp.GetHeaders().CopyAll() {
+		header.Add(kv.F0, string(kv.F1))
+	}
+
+	status := int(resp.GetStatusCode())
+
+	// Consume the response body as a stream wrapped in an io.ReadCloser. The
+	// "handled ok" future is resolved from a goroutine for the same reason as
+	// the trailers future — its write blocks until the host consumes it, which
+	// happens while we read the body stream below.
+	doneW, doneR := httptypes.MakeFutureResultUnitErrorCode()
+	go doneW.Write(witTypes.Ok[witTypes.Unit, httptypes.ErrorCode](witTypes.Unit{}))
+	bodyStream, _ := httptypes.ResponseConsumeBody(resp, doneR)
+
+	return &http.Response{
+		StatusCode:    status,
+		Status:        fmt.Sprintf("%d %s", status, http.StatusText(status)),
+		Proto:         "HTTP/1.1",
+		ProtoMajor:    1,
+		ProtoMinor:    1,
+		Header:        header,
+		Body:          &responseBody{stream: bodyStream},
+		ContentLength: contentLength(header),
+		Request:       req,
+	}, nil
+}
+
+// requestBody turns req.Body into an optional stream the host reads from. A
+// goroutine copies the body into the stream writer; it runs concurrently with
+// the blocking Send because a goroutine blocked on WriteAll yields via
+// wasiOnIdle.
+func requestBody(req *http.Request) witTypes.Option[*witTypes.StreamReader[uint8]] {
+	if req.Body == nil || req.Body == http.NoBody {
+		return witTypes.None[*witTypes.StreamReader[uint8]]()
+	}
+	w, r := httptypes.MakeStreamU8()
+	go func() {
+		defer func() { _ = req.Body.Close() }()
+		defer w.Drop()
+		buf := make([]byte, 16*1024)
+		for {
+			n, err := req.Body.Read(buf)
+			if n > 0 {
+				w.WriteAll(buf[:n])
+			}
+			if err != nil {
+				return
+			}
+		}
+	}()
+	return witTypes.Some(r)
+}
+
+// responseBody adapts a wasi stream<u8> to io.ReadCloser.
+type responseBody struct {
+	stream *witTypes.StreamReader[uint8]
+	buf    []byte // leftover bytes from the last stream read
+}
+
+func (b *responseBody) Read(p []byte) (int, error) {
+	if len(b.buf) == 0 {
+		chunk := make([]byte, len(p))
+		n := b.stream.Read(chunk)
+		if n == 0 {
+			if b.stream.WriterDropped() {
+				return 0, io.EOF
+			}
+			return 0, nil
+		}
+		b.buf = chunk[:n]
+	}
+	n := copy(p, b.buf)
+	b.buf = b.buf[n:]
+	return n, nil
+}
+
+func (b *responseBody) Close() error {
+	b.stream.Drop()
+	return nil
+}
+
+func methodOf(m string) httptypes.Method {
+	switch strings.ToUpper(m) {
+	case "", "GET":
+		return httptypes.MakeMethodGet()
+	case "HEAD":
+		return httptypes.MakeMethodHead()
+	case "POST":
+		return httptypes.MakeMethodPost()
+	case "PUT":
+		return httptypes.MakeMethodPut()
+	case "DELETE":
+		return httptypes.MakeMethodDelete()
+	case "CONNECT":
+		return httptypes.MakeMethodConnect()
+	case "OPTIONS":
+		return httptypes.MakeMethodOptions()
+	case "TRACE":
+		return httptypes.MakeMethodTrace()
+	case "PATCH":
+		return httptypes.MakeMethodPatch()
+	default:
+		return httptypes.MakeMethodOther(m)
+	}
+}
+
+func schemeOf(s string) httptypes.Scheme {
+	switch strings.ToLower(s) {
+	case "http":
+		return httptypes.MakeSchemeHttp()
+	case "https", "":
+		return httptypes.MakeSchemeHttps()
+	default:
+		return httptypes.MakeSchemeOther(s)
+	}
+}
+
+// timeoutFromDeadline returns the remaining time until deadline in nanoseconds,
+// and whether a positive budget remains. Pure (clock passed in) so it is
+// natively testable.
+func timeoutFromDeadline(deadline, now time.Time) (uint64, bool) {
+	remaining := deadline.Sub(now)
+	if remaining <= 0 {
+		return 0, false
+	}
+	return uint64(remaining.Nanoseconds()), true
+}
+
+func contentLength(h http.Header) int64 {
+	if cl := h.Get("Content-Length"); cl != "" {
+		var n int64
+		if _, err := fmt.Sscan(cl, &n); err == nil {
+			return n
+		}
+	}
+	return -1
+}
+
+func headerErr(e httptypes.HeaderError) string {
+	switch e.Tag() {
+	case httptypes.HeaderErrorInvalidSyntax:
+		return "invalid syntax"
+	case httptypes.HeaderErrorForbidden:
+		return "forbidden"
+	case httptypes.HeaderErrorImmutable:
+		return "immutable"
+	default:
+		return fmt.Sprintf("header error (tag %d)", e.Tag())
+	}
+}
+
+// errorCodeString renders a wasi:http error-code into a readable message. It
+// covers the meaningful families (DNS, destination, connection, TLS,
+// request/response protocol, size/policy limits) and falls back to the tag for
+// anything else.
+func errorCodeString(e httptypes.ErrorCode) string {
+	switch e.Tag() {
+	// DNS
+	case httptypes.ErrorCodeDnsTimeout:
+		return "DNS timeout"
+	case httptypes.ErrorCodeDnsError:
+		return "DNS error"
+	// destination
+	case httptypes.ErrorCodeDestinationNotFound:
+		return "destination not found"
+	case httptypes.ErrorCodeDestinationUnavailable:
+		return "destination unavailable"
+	case httptypes.ErrorCodeDestinationIpProhibited:
+		return "destination IP prohibited"
+	case httptypes.ErrorCodeDestinationIpUnroutable:
+		return "destination IP unroutable"
+	// connection
+	case httptypes.ErrorCodeConnectionRefused:
+		return "connection refused"
+	case httptypes.ErrorCodeConnectionTerminated:
+		return "connection terminated"
+	case httptypes.ErrorCodeConnectionTimeout:
+		return "connection timeout"
+	case httptypes.ErrorCodeConnectionReadTimeout:
+		return "connection read timeout"
+	case httptypes.ErrorCodeConnectionWriteTimeout:
+		return "connection write timeout"
+	case httptypes.ErrorCodeConnectionLimitReached:
+		return "connection limit reached"
+	// TLS
+	case httptypes.ErrorCodeTlsProtocolError:
+		return "TLS protocol error"
+	case httptypes.ErrorCodeTlsCertificateError:
+		return "TLS certificate error"
+	case httptypes.ErrorCodeTlsAlertReceived:
+		return "TLS alert received"
+	// request / response protocol
+	case httptypes.ErrorCodeHttpRequestDenied:
+		return "HTTP request denied"
+	case httptypes.ErrorCodeHttpRequestUriInvalid:
+		return "HTTP request URI invalid"
+	case httptypes.ErrorCodeHttpRequestUriTooLong:
+		return "HTTP request URI too long"
+	case httptypes.ErrorCodeHttpResponseIncomplete:
+		return "HTTP response incomplete"
+	case httptypes.ErrorCodeHttpResponseTimeout:
+		return "HTTP response timeout"
+	case httptypes.ErrorCodeHttpUpgradeFailed:
+		return "HTTP upgrade failed"
+	case httptypes.ErrorCodeHttpProtocolError:
+		return "HTTP protocol error"
+	// size / policy limits
+	case httptypes.ErrorCodeHttpRequestBodySize:
+		return "HTTP request body too large"
+	case httptypes.ErrorCodeHttpResponseBodySize:
+		return "HTTP response body too large"
+	case httptypes.ErrorCodeHttpResponseHeaderSize, httptypes.ErrorCodeHttpResponseHeaderSectionSize:
+		return "HTTP response headers too large"
+	case httptypes.ErrorCodeLoopDetected:
+		return "loop detected"
+	case httptypes.ErrorCodeConfigurationError:
+		return "configuration error"
+	case httptypes.ErrorCodeInternalError:
+		return "internal error"
+	default:
+		return fmt.Sprintf("http error (tag %d)", e.Tag())
+	}
+}
+
+func init() {
+	// Route net/http through wasi:http/client. The default transport can't dial
+	// on this target, so any code using http.DefaultClient depends on this.
+	http.DefaultClient.Transport = Transport{}
+	http.DefaultTransport = Transport{}
+}
diff --git a/sdks/go/golem/internal/exports/export_golem_agent_guest/exports.go b/sdks/go/golem/internal/exports/export_golem_agent_guest/exports.go
new file mode 100644
index 0000000000..4ed1cee207
--- /dev/null
+++ b/sdks/go/golem/internal/exports/export_golem_agent_guest/exports.go
@@ -0,0 +1,67 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 export_golem_agent_guest holds the hand-written export slots for
+// golem:agent/guest@2.0.0.
+//
+// These are NOT generated: `componentize-go bindings` is run with
+// --export-pkg-name pointing here, so the generated wasmexport glue in
+// internal/wit/wit_exports calls into this package while never overwriting it.
+// The SDK fills the slots from its init(); leaving one nil is a programming
+// error and panics with a clear message rather than a nil-deref.
+//
+// initialize/invoke are `async func` in WIT, but the async lift is handled
+// entirely by the generated glue (witAsync.Run), so these are plain blocking
+// Go functions.
+package export_golem_agent_guest
+
+import (
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// Exports is the set of slots the SDK must fill before the component is invoked.
+var Exports struct {
+	Initialize         func(agentType string, input types.SchemaValueTree, principal common.Principal) witTypes.Result[witTypes.Unit, common.AgentError]
+	Invoke             func(methodName string, input types.SchemaValueTree, principal common.Principal) witTypes.Result[witTypes.Option[types.SchemaValueTree], common.AgentError]
+	GetDefinition      func() common.AgentType
+	DiscoverAgentTypes func() witTypes.Result[[]common.AgentType, common.AgentError]
+}
+
+func mustBeSet(name string, set bool) {
+	if !set {
+		panic("golem: export " + name + " was not registered — is the SDK imported?")
+	}
+}
+
+func Initialize(agentType string, input types.SchemaValueTree, principal common.Principal) witTypes.Result[witTypes.Unit, common.AgentError] {
+	mustBeSet("initialize", Exports.Initialize != nil)
+	return Exports.Initialize(agentType, input, principal)
+}
+
+func Invoke(methodName string, input types.SchemaValueTree, principal common.Principal) witTypes.Result[witTypes.Option[types.SchemaValueTree], common.AgentError] {
+	mustBeSet("invoke", Exports.Invoke != nil)
+	return Exports.Invoke(methodName, input, principal)
+}
+
+func GetDefinition() common.AgentType {
+	mustBeSet("get-definition", Exports.GetDefinition != nil)
+	return Exports.GetDefinition()
+}
+
+func DiscoverAgentTypes() witTypes.Result[[]common.AgentType, common.AgentError] {
+	mustBeSet("discover-agent-types", Exports.DiscoverAgentTypes != nil)
+	return Exports.DiscoverAgentTypes()
+}
diff --git a/sdks/go/golem/internal/exports/export_golem_api_load_snapshot/exports.go b/sdks/go/golem/internal/exports/export_golem_api_load_snapshot/exports.go
new file mode 100644
index 0000000000..d45949d239
--- /dev/null
+++ b/sdks/go/golem/internal/exports/export_golem_api_load_snapshot/exports.go
@@ -0,0 +1,33 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 export_golem_api_load_snapshot holds the hand-written export slot for
+// golem:api/load-snapshot@1.5.0. See export_golem_agent_guest for the pattern.
+package export_golem_api_load_snapshot
+
+import (
+	host "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_host"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+var Exports struct {
+	Load func(snapshot host.Snapshot) witTypes.Result[witTypes.Unit, string]
+}
+
+func Load(snapshot host.Snapshot) witTypes.Result[witTypes.Unit, string] {
+	if Exports.Load == nil {
+		panic("golem: export load-snapshot was not registered — is the SDK imported?")
+	}
+	return Exports.Load(snapshot)
+}
diff --git a/sdks/go/golem/internal/exports/export_golem_api_save_snapshot/exports.go b/sdks/go/golem/internal/exports/export_golem_api_save_snapshot/exports.go
new file mode 100644
index 0000000000..f2a5b81392
--- /dev/null
+++ b/sdks/go/golem/internal/exports/export_golem_api_save_snapshot/exports.go
@@ -0,0 +1,31 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 export_golem_api_save_snapshot holds the hand-written export slot for
+// golem:api/save-snapshot@1.5.0 (an `async func` in WIT; the async lift lives in
+// the generated glue). See export_golem_agent_guest for the pattern.
+package export_golem_api_save_snapshot
+
+import host "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_host"
+
+var Exports struct {
+	Save func() host.Snapshot
+}
+
+func Save() host.Snapshot {
+	if Exports.Save == nil {
+		panic("golem: export save-snapshot was not registered — is the SDK imported?")
+	}
+	return Exports.Save()
+}
diff --git a/sdks/go/golem/internal/wit/golem_agent_common/empty.s b/sdks/go/golem/internal/wit/golem_agent_common/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_agent_common/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_agent_common/wit_bindings.go b/sdks/go/golem/internal/wit/golem_agent_common/wit_bindings.go
new file mode 100644
index 0000000000..1daafc945d
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_agent_common/wit_bindings.go
@@ -0,0 +1,621 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_agent_common
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+type SchemaGraph = golem_core_types.SchemaGraph
+type TypeNodeIndex = int32
+type TypedSchemaValue = golem_core_types.TypedSchemaValue
+type MetadataEnvelope = golem_core_types.MetadataEnvelope
+type AgentId = golem_core_types.AgentId
+type AccountId = golem_core_types.AccountId
+type ComponentId = golem_core_types.ComponentId
+type Duration = uint64
+
+const (
+	AgentModeDurable   uint8 = 0
+	AgentModeEphemeral uint8 = 1
+)
+
+type AgentMode = uint8
+
+const (
+	AutoInjectedKindPrincipal uint8 = 0
+)
+
+type AutoInjectedKind = uint8
+
+const (
+	FieldSourceUserSupplied uint8 = 0
+	FieldSourceAutoInjected uint8 = 1
+)
+
+type FieldSource struct {
+	tag   uint8
+	value any
+}
+
+func (self FieldSource) Tag() uint8 {
+	return self.tag
+}
+
+func (self FieldSource) AutoInjected() AutoInjectedKind {
+	if self.tag != FieldSourceAutoInjected {
+		panic("tag mismatch")
+	}
+	return self.value.(AutoInjectedKind)
+}
+
+func MakeFieldSourceUserSupplied() FieldSource {
+	return FieldSource{FieldSourceUserSupplied, nil}
+}
+func MakeFieldSourceAutoInjected(value AutoInjectedKind) FieldSource {
+	return FieldSource{FieldSourceAutoInjected, value}
+}
+
+type NamedField struct {
+	Name   string
+	Source FieldSource
+	// Index into the owning agent-type / dependency `schema` graph.
+	Schema   int32
+	Metadata golem_core_types.MetadataEnvelope
+}
+
+const (
+	InputSchemaParameters uint8 = 0
+)
+
+// Ordered, named input parameters with per-field source annotation.
+type InputSchema struct {
+	tag   uint8
+	value any
+}
+
+func (self InputSchema) Tag() uint8 {
+	return self.tag
+}
+
+func (self InputSchema) Parameters() []NamedField {
+	if self.tag != InputSchemaParameters {
+		panic("tag mismatch")
+	}
+	return self.value.([]NamedField)
+}
+
+func MakeInputSchemaParameters(value []NamedField) InputSchema {
+	return InputSchema{InputSchemaParameters, value}
+}
+
+const (
+	OutputSchemaUnit uint8 = 0
+	// Index into the owning agent-type / dependency `schema` graph.
+	OutputSchemaSingle uint8 = 1
+)
+
+// Output is either unit (no value) or a single value of the given type.
+type OutputSchema struct {
+	tag   uint8
+	value any
+}
+
+func (self OutputSchema) Tag() uint8 {
+	return self.tag
+}
+
+func (self OutputSchema) Single() int32 {
+	if self.tag != OutputSchemaSingle {
+		panic("tag mismatch")
+	}
+	return self.value.(int32)
+}
+
+func MakeOutputSchemaUnit() OutputSchema {
+	return OutputSchema{OutputSchemaUnit, nil}
+}
+func MakeOutputSchemaSingle(value int32) OutputSchema {
+	return OutputSchema{OutputSchemaSingle, value}
+}
+
+const (
+	CachePolicyNoCache    uint8 = 0
+	CachePolicyUntilWrite uint8 = 1
+	CachePolicyTtl        uint8 = 2
+)
+
+type CachePolicy struct {
+	tag   uint8
+	value any
+}
+
+func (self CachePolicy) Tag() uint8 {
+	return self.tag
+}
+
+func (self CachePolicy) Ttl() uint64 {
+	if self.tag != CachePolicyTtl {
+		panic("tag mismatch")
+	}
+	return self.value.(uint64)
+}
+
+func MakeCachePolicyNoCache() CachePolicy {
+	return CachePolicy{CachePolicyNoCache, nil}
+}
+func MakeCachePolicyUntilWrite() CachePolicy {
+	return CachePolicy{CachePolicyUntilWrite, nil}
+}
+func MakeCachePolicyTtl(value uint64) CachePolicy {
+	return CachePolicy{CachePolicyTtl, value}
+}
+
+type ReadOnlyConfig struct {
+	CachePolicy   CachePolicy
+	UsesPrincipal bool
+}
+
+type CorsOptions struct {
+	AllowedPatterns []string
+}
+
+const (
+	HttpMethodGet     uint8 = 0
+	HttpMethodHead    uint8 = 1
+	HttpMethodPost    uint8 = 2
+	HttpMethodPut     uint8 = 3
+	HttpMethodDelete  uint8 = 4
+	HttpMethodConnect uint8 = 5
+	HttpMethodOptions uint8 = 6
+	HttpMethodTrace   uint8 = 7
+	HttpMethodPatch   uint8 = 8
+	HttpMethodCustom  uint8 = 9
+)
+
+type HttpMethod struct {
+	tag   uint8
+	value any
+}
+
+func (self HttpMethod) Tag() uint8 {
+	return self.tag
+}
+
+func (self HttpMethod) Custom() string {
+	if self.tag != HttpMethodCustom {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+
+func MakeHttpMethodGet() HttpMethod {
+	return HttpMethod{HttpMethodGet, nil}
+}
+func MakeHttpMethodHead() HttpMethod {
+	return HttpMethod{HttpMethodHead, nil}
+}
+func MakeHttpMethodPost() HttpMethod {
+	return HttpMethod{HttpMethodPost, nil}
+}
+func MakeHttpMethodPut() HttpMethod {
+	return HttpMethod{HttpMethodPut, nil}
+}
+func MakeHttpMethodDelete() HttpMethod {
+	return HttpMethod{HttpMethodDelete, nil}
+}
+func MakeHttpMethodConnect() HttpMethod {
+	return HttpMethod{HttpMethodConnect, nil}
+}
+func MakeHttpMethodOptions() HttpMethod {
+	return HttpMethod{HttpMethodOptions, nil}
+}
+func MakeHttpMethodTrace() HttpMethod {
+	return HttpMethod{HttpMethodTrace, nil}
+}
+func MakeHttpMethodPatch() HttpMethod {
+	return HttpMethod{HttpMethodPatch, nil}
+}
+func MakeHttpMethodCustom(value string) HttpMethod {
+	return HttpMethod{HttpMethodCustom, value}
+}
+
+const (
+	SystemVariableAgentType    uint8 = 0
+	SystemVariableAgentVersion uint8 = 1
+)
+
+type SystemVariable = uint8
+
+type PathVariable struct {
+	VariableName string
+}
+
+const (
+	PathSegmentLiteral        uint8 = 0
+	PathSegmentSystemVariable uint8 = 1
+	PathSegmentPathVariable   uint8 = 2
+	// only allowed as the last segment
+	PathSegmentRemainingPathVariable uint8 = 3
+)
+
+type PathSegment struct {
+	tag   uint8
+	value any
+}
+
+func (self PathSegment) Tag() uint8 {
+	return self.tag
+}
+
+func (self PathSegment) Literal() string {
+	if self.tag != PathSegmentLiteral {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self PathSegment) SystemVariable() SystemVariable {
+	if self.tag != PathSegmentSystemVariable {
+		panic("tag mismatch")
+	}
+	return self.value.(SystemVariable)
+}
+func (self PathSegment) PathVariable() PathVariable {
+	if self.tag != PathSegmentPathVariable {
+		panic("tag mismatch")
+	}
+	return self.value.(PathVariable)
+}
+func (self PathSegment) RemainingPathVariable() PathVariable {
+	if self.tag != PathSegmentRemainingPathVariable {
+		panic("tag mismatch")
+	}
+	return self.value.(PathVariable)
+}
+
+func MakePathSegmentLiteral(value string) PathSegment {
+	return PathSegment{PathSegmentLiteral, value}
+}
+func MakePathSegmentSystemVariable(value SystemVariable) PathSegment {
+	return PathSegment{PathSegmentSystemVariable, value}
+}
+func MakePathSegmentPathVariable(value PathVariable) PathSegment {
+	return PathSegment{PathSegmentPathVariable, value}
+}
+func MakePathSegmentRemainingPathVariable(value PathVariable) PathSegment {
+	return PathSegment{PathSegmentRemainingPathVariable, value}
+}
+
+type HeaderVariable struct {
+	HeaderName   string
+	VariableName string
+}
+
+type QueryVariable struct {
+	QueryParamName string
+	VariableName   string
+}
+
+type AuthDetails struct {
+	Required bool
+}
+
+type HttpMountDetails struct {
+	PathPrefix    []PathSegment
+	AuthDetails   witTypes.Option[AuthDetails]
+	PhantomAgent  bool
+	CorsOptions   CorsOptions
+	WebhookSuffix []PathSegment
+}
+
+type HttpEndpointDetails struct {
+	HttpMethod  HttpMethod
+	PathSuffix  []PathSegment
+	HeaderVars  []HeaderVariable
+	QueryVars   []QueryVariable
+	AuthDetails witTypes.Option[AuthDetails]
+	CorsOptions CorsOptions
+}
+
+type AgentMethod struct {
+	Name         string
+	Description  string
+	HttpEndpoint []HttpEndpointDetails
+	PromptHint   witTypes.Option[string]
+	InputSchema  InputSchema
+	OutputSchema OutputSchema
+	ReadOnly     witTypes.Option[ReadOnlyConfig]
+}
+
+type OidcPrincipal struct {
+	Sub               string
+	Issuer            string
+	Email             witTypes.Option[string]
+	Name              witTypes.Option[string]
+	EmailVerified     witTypes.Option[bool]
+	GivenName         witTypes.Option[string]
+	FamilyName        witTypes.Option[string]
+	Picture           witTypes.Option[string]
+	PreferredUsername witTypes.Option[string]
+	Claims            string
+}
+
+type AgentPrincipal struct {
+	AgentId golem_core_types.AgentId
+}
+
+type GolemUserPrincipal struct {
+	AccountId golem_core_types.AccountId
+}
+
+const (
+	PrincipalOidc      uint8 = 0
+	PrincipalAgent     uint8 = 1
+	PrincipalGolemUser uint8 = 2
+	PrincipalAnonymous uint8 = 3
+)
+
+type Principal struct {
+	tag   uint8
+	value any
+}
+
+func (self Principal) Tag() uint8 {
+	return self.tag
+}
+
+func (self Principal) Oidc() OidcPrincipal {
+	if self.tag != PrincipalOidc {
+		panic("tag mismatch")
+	}
+	return self.value.(OidcPrincipal)
+}
+func (self Principal) Agent() AgentPrincipal {
+	if self.tag != PrincipalAgent {
+		panic("tag mismatch")
+	}
+	return self.value.(AgentPrincipal)
+}
+func (self Principal) GolemUser() GolemUserPrincipal {
+	if self.tag != PrincipalGolemUser {
+		panic("tag mismatch")
+	}
+	return self.value.(GolemUserPrincipal)
+}
+
+func MakePrincipalOidc(value OidcPrincipal) Principal {
+	return Principal{PrincipalOidc, value}
+}
+func MakePrincipalAgent(value AgentPrincipal) Principal {
+	return Principal{PrincipalAgent, value}
+}
+func MakePrincipalGolemUser(value GolemUserPrincipal) Principal {
+	return Principal{PrincipalGolemUser, value}
+}
+func MakePrincipalAnonymous() Principal {
+	return Principal{PrincipalAnonymous, nil}
+}
+
+type AgentConstructor struct {
+	Name        witTypes.Option[string]
+	Description string
+	PromptHint  witTypes.Option[string]
+	InputSchema InputSchema
+}
+
+// Dependent agent type. All schema roots inside it resolve against its own
+// `schema`, not against the parent agent-type's graph.
+type AgentDependency struct {
+	TypeName    string
+	Description witTypes.Option[string]
+	Schema      golem_core_types.SchemaGraph
+	Constructor AgentConstructor
+	Methods     []AgentMethod
+}
+
+const (
+	SnapshottingConfigDefault uint8 = 0
+	// current default in the server
+	SnapshottingConfigPeriodic         uint8 = 1
+	SnapshottingConfigEveryNInvocation uint8 = 2
+)
+
+type SnapshottingConfig struct {
+	tag   uint8
+	value any
+}
+
+func (self SnapshottingConfig) Tag() uint8 {
+	return self.tag
+}
+
+func (self SnapshottingConfig) Periodic() uint64 {
+	if self.tag != SnapshottingConfigPeriodic {
+		panic("tag mismatch")
+	}
+	return self.value.(uint64)
+}
+func (self SnapshottingConfig) EveryNInvocation() uint16 {
+	if self.tag != SnapshottingConfigEveryNInvocation {
+		panic("tag mismatch")
+	}
+	return self.value.(uint16)
+}
+
+func MakeSnapshottingConfigDefault() SnapshottingConfig {
+	return SnapshottingConfig{SnapshottingConfigDefault, nil}
+}
+func MakeSnapshottingConfigPeriodic(value uint64) SnapshottingConfig {
+	return SnapshottingConfig{SnapshottingConfigPeriodic, value}
+}
+func MakeSnapshottingConfigEveryNInvocation(value uint16) SnapshottingConfig {
+	return SnapshottingConfig{SnapshottingConfigEveryNInvocation, value}
+}
+
+const (
+	SnapshottingDisabled uint8 = 0
+	SnapshottingEnabled  uint8 = 1
+)
+
+type Snapshotting struct {
+	tag   uint8
+	value any
+}
+
+func (self Snapshotting) Tag() uint8 {
+	return self.tag
+}
+
+func (self Snapshotting) Enabled() SnapshottingConfig {
+	if self.tag != SnapshottingEnabled {
+		panic("tag mismatch")
+	}
+	return self.value.(SnapshottingConfig)
+}
+
+func MakeSnapshottingDisabled() Snapshotting {
+	return Snapshotting{SnapshottingDisabled, nil}
+}
+func MakeSnapshottingEnabled(value SnapshottingConfig) Snapshotting {
+	return Snapshotting{SnapshottingEnabled, value}
+}
+
+const (
+	AgentConfigSourceLocal  uint8 = 0
+	AgentConfigSourceSecret uint8 = 1
+)
+
+type AgentConfigSource = uint8
+
+type AgentConfigDeclaration struct {
+	Source AgentConfigSource
+	Path   []string
+	// Index into the owning agent-type `schema` graph.
+	ValueType int32
+}
+
+// Full agent type declaration.
+//
+// `schema` is the per-agent type-node pool. Constructor / method / config
+// schema roots below are `type-node-index` values into `schema`. The
+// `schema.root` field is a structurally-required placeholder and is not the
+// semantic root of the agent type.
+type AgentType struct {
+	TypeName       string
+	Description    string
+	SourceLanguage string
+	Schema         golem_core_types.SchemaGraph
+	Constructor    AgentConstructor
+	Methods        []AgentMethod
+	Dependencies   []AgentDependency
+	Mode           AgentMode
+	HttpMount      witTypes.Option[HttpMountDetails]
+	Snapshotting   Snapshotting
+	Config         []AgentConfigDeclaration
+}
+
+// Associates an agent type with a component that implements it
+type RegisteredAgentType struct {
+	AgentType     AgentType
+	ImplementedBy golem_core_types.ComponentId
+}
+
+type TypedAgentConfigValue struct {
+	Path  []string
+	Value golem_core_types.TypedSchemaValue
+}
+
+const (
+	AgentErrorInvalidInput   uint8 = 0
+	AgentErrorInvalidMethod  uint8 = 1
+	AgentErrorInvalidType    uint8 = 2
+	AgentErrorInvalidAgentId uint8 = 3
+	AgentErrorCustomError    uint8 = 4
+)
+
+// Agent-level failures
+type AgentError struct {
+	tag   uint8
+	value any
+}
+
+func (self AgentError) Tag() uint8 {
+	return self.tag
+}
+
+func (self AgentError) InvalidInput() string {
+	if self.tag != AgentErrorInvalidInput {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self AgentError) InvalidMethod() string {
+	if self.tag != AgentErrorInvalidMethod {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self AgentError) InvalidType() string {
+	if self.tag != AgentErrorInvalidType {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self AgentError) InvalidAgentId() string {
+	if self.tag != AgentErrorInvalidAgentId {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self AgentError) CustomError() golem_core_types.TypedSchemaValue {
+	if self.tag != AgentErrorCustomError {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_core_types.TypedSchemaValue)
+}
+
+func MakeAgentErrorInvalidInput(value string) AgentError {
+	return AgentError{AgentErrorInvalidInput, value}
+}
+func MakeAgentErrorInvalidMethod(value string) AgentError {
+	return AgentError{AgentErrorInvalidMethod, value}
+}
+func MakeAgentErrorInvalidType(value string) AgentError {
+	return AgentError{AgentErrorInvalidType, value}
+}
+func MakeAgentErrorInvalidAgentId(value string) AgentError {
+	return AgentError{AgentErrorInvalidAgentId, value}
+}
+func MakeAgentErrorCustomError(value golem_core_types.TypedSchemaValue) AgentError {
+	return AgentError{AgentErrorCustomError, value}
+}
diff --git a/sdks/go/golem/internal/wit/golem_agent_guest/empty.s b/sdks/go/golem/internal/wit/golem_agent_guest/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_agent_guest/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_agent_guest/wit_bindings.go b/sdks/go/golem/internal/wit/golem_agent_guest/wit_bindings.go
new file mode 100644
index 0000000000..5ce27de1d8
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_agent_guest/wit_bindings.go
@@ -0,0 +1,42 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_agent_guest
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+)
+
+type SchemaValueTree = golem_core_types.SchemaValueTree
+type AgentError = golem_agent_common.AgentError
+type AgentType = golem_agent_common.AgentType
+type Principal = golem_agent_common.Principal
diff --git a/sdks/go/golem/internal/wit/golem_agent_host/empty.s b/sdks/go/golem/internal/wit/golem_agent_host/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_agent_host/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_agent_host/wit_bindings.go b/sdks/go/golem/internal/wit/golem_agent_host/wit_bindings.go
new file mode 100644
index 0000000000..a1c7b39e60
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_agent_host/wit_bindings.go
@@ -0,0 +1,28546 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_agent_host
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_system_clock"
+	witAsync "go.bytecodealliance.org/pkg/wit/async"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type ComponentId = golem_core_types.ComponentId
+type Uuid = golem_core_types.Uuid
+type PromiseId = golem_core_types.PromiseId
+type SchemaGraph = golem_core_types.SchemaGraph
+type SchemaValueTree = golem_core_types.SchemaValueTree
+type TypedSchemaValue = golem_core_types.TypedSchemaValue
+type Datetime = wasi_clocks_0_3_0_system_clock.Instant
+type AgentError = golem_agent_common.AgentError
+type AgentType = golem_agent_common.AgentType
+type RegisteredAgentType = golem_agent_common.RegisteredAgentType
+type TypedAgentConfigValue = golem_agent_common.TypedAgentConfigValue
+
+const (
+	// Protocol level error
+	RpcErrorProtocolError uint8 = 0
+	// Access denied
+	RpcErrorDenied uint8 = 1
+	// Target agent or function not found
+	RpcErrorNotFound uint8 = 2
+	// Internal error on the remote side
+	RpcErrorRemoteInternalError uint8 = 3
+	// The remote endpoint returned an agent-domain error
+	RpcErrorRemoteAgentError uint8 = 4
+)
+
+// Possible failures of an RPC call
+type RpcError struct {
+	tag   uint8
+	value any
+}
+
+func (self RpcError) Tag() uint8 {
+	return self.tag
+}
+
+func (self RpcError) ProtocolError() string {
+	if self.tag != RpcErrorProtocolError {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self RpcError) Denied() string {
+	if self.tag != RpcErrorDenied {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self RpcError) NotFound() string {
+	if self.tag != RpcErrorNotFound {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self RpcError) RemoteInternalError() string {
+	if self.tag != RpcErrorRemoteInternalError {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self RpcError) RemoteAgentError() golem_agent_common.AgentError {
+	if self.tag != RpcErrorRemoteAgentError {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_agent_common.AgentError)
+}
+
+func MakeRpcErrorProtocolError(value string) RpcError {
+	return RpcError{RpcErrorProtocolError, value}
+}
+func MakeRpcErrorDenied(value string) RpcError {
+	return RpcError{RpcErrorDenied, value}
+}
+func MakeRpcErrorNotFound(value string) RpcError {
+	return RpcError{RpcErrorNotFound, value}
+}
+func MakeRpcErrorRemoteInternalError(value string) RpcError {
+	return RpcError{RpcErrorRemoteInternalError, value}
+}
+func MakeRpcErrorRemoteAgentError(value golem_agent_common.AgentError) RpcError {
+	return RpcError{RpcErrorRemoteAgentError, value}
+}
+
+// Final identity allocated for one remote invocation. For an ephemeral
+// target, `agent-id` contains the generated one-shot phantom ID.
+type InvocationMetadata struct {
+	AgentId        string
+	IdempotencyKey string
+}
+
+// Result of an awaited invocation together with its final identity.
+type InvocationResultWithMetadata struct {
+	Metadata InvocationMetadata
+	Result   witTypes.Option[golem_core_types.SchemaValueTree]
+}
+
+// Receipt returned when an invocation has been scheduled.
+type ScheduledInvocationReceipt struct {
+	Metadata InvocationMetadata
+}
+
+//go:wasmimport golem:agent/host@2.0.0 [resource-drop]wasm-rpc
+func resourceDropWasmRpc(handle int32)
+
+// An RPC client for invoking remote agents
+type WasmRpc struct {
+	handle *witRuntime.Handle
+}
+
+func (self *WasmRpc) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *WasmRpc) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *WasmRpc) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *WasmRpc) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropWasmRpc(handle)
+	}
+}
+
+func WasmRpcFromOwnHandle(handleValue int32) *WasmRpc {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &WasmRpc{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropWasmRpc(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func WasmRpcFromBorrowHandle(handleValue int32) *WasmRpc {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &WasmRpc{handle}
+}
+
+//go:wasmimport golem:agent/host@2.0.0 [resource-drop]future-invoke-result
+func resourceDropFutureInvokeResult(handle int32)
+
+// Represents an asynchronous invocation result
+type FutureInvokeResult struct {
+	handle *witRuntime.Handle
+}
+
+func (self *FutureInvokeResult) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *FutureInvokeResult) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *FutureInvokeResult) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *FutureInvokeResult) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropFutureInvokeResult(handle)
+	}
+}
+
+func FutureInvokeResultFromOwnHandle(handleValue int32) *FutureInvokeResult {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &FutureInvokeResult{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropFutureInvokeResult(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func FutureInvokeResultFromBorrowHandle(handleValue int32) *FutureInvokeResult {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &FutureInvokeResult{handle}
+}
+
+// Asynchronous invocation handle together with its final identity.
+type AsyncInvocationWithMetadata struct {
+	Metadata InvocationMetadata
+	Future   *FutureInvokeResult
+}
+
+//go:wasmimport golem:agent/host@2.0.0 [resource-drop]cancellation-token
+func resourceDropCancellationToken(handle int32)
+
+// Cancellation token for scheduled invocations
+type CancellationToken struct {
+	handle *witRuntime.Handle
+}
+
+func (self *CancellationToken) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *CancellationToken) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *CancellationToken) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *CancellationToken) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropCancellationToken(handle)
+	}
+}
+
+func CancellationTokenFromOwnHandle(handleValue int32) *CancellationToken {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &CancellationToken{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropCancellationToken(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func CancellationTokenFromBorrowHandle(handleValue int32) *CancellationToken {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &CancellationToken{handle}
+}
+
+// Receipt for a scheduled invocation that can still be cancelled.
+type CancelableScheduledInvocationReceipt struct {
+	Metadata          InvocationMetadata
+	CancellationToken *CancellationToken
+}
+
+//go:wasmimport golem:agent/host@2.0.0 get-all-agent-types
+func wasm_import_get_all_agent_types(arg0 uintptr)
+
+func GetAllAgentTypes() []golem_agent_common.RegisteredAgentType {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	wasm_import_get_all_agent_types(returnArea)
+	result502 := make([]golem_agent_common.RegisteredAgentType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)))), index*(48+36*4))
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+		value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+		value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+		result174 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(56+22*4))
+			var variant162 golem_core_types.SchemaTypeBody
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 1:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+			case 2:
+				var option6 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option6 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option = witTypes.Some[golem_core_types.NumericBound](variant)
+					default:
+						panic("unreachable")
+					}
+					var option3 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option3 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant2 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant2 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant2 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant2 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option3 = witTypes.Some[golem_core_types.NumericBound](variant2)
+					default:
+						panic("unreachable")
+					}
+					var option5 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option5 = witTypes.None[string]()
+					case 1:
+						value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option5 = witTypes.Some[string](value4)
+					default:
+						panic("unreachable")
+					}
+
+					option6 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option, option3, option5})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyS8Type(option6)
+
+			case 3:
+				var option13 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option13 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option8 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option8 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant7 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant7 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant7 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant7 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option8 = witTypes.Some[golem_core_types.NumericBound](variant7)
+					default:
+						panic("unreachable")
+					}
+					var option10 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option10 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant9 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant9 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant9 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant9 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option10 = witTypes.Some[golem_core_types.NumericBound](variant9)
+					default:
+						panic("unreachable")
+					}
+					var option12 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option12 = witTypes.None[string]()
+					case 1:
+						value11 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option12 = witTypes.Some[string](value11)
+					default:
+						panic("unreachable")
+					}
+
+					option13 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option8, option10, option12})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyS16Type(option13)
+
+			case 4:
+				var option20 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option20 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option15 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option15 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant14 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant14 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant14 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant14 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option15 = witTypes.Some[golem_core_types.NumericBound](variant14)
+					default:
+						panic("unreachable")
+					}
+					var option17 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option17 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant16 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant16 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant16 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant16 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option17 = witTypes.Some[golem_core_types.NumericBound](variant16)
+					default:
+						panic("unreachable")
+					}
+					var option19 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option19 = witTypes.None[string]()
+					case 1:
+						value18 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option19 = witTypes.Some[string](value18)
+					default:
+						panic("unreachable")
+					}
+
+					option20 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option15, option17, option19})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyS32Type(option20)
+
+			case 5:
+				var option27 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option27 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option22 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option22 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant21 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant21 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant21 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant21 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option22 = witTypes.Some[golem_core_types.NumericBound](variant21)
+					default:
+						panic("unreachable")
+					}
+					var option24 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option24 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant23 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant23 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant23 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant23 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option24 = witTypes.Some[golem_core_types.NumericBound](variant23)
+					default:
+						panic("unreachable")
+					}
+					var option26 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option26 = witTypes.None[string]()
+					case 1:
+						value25 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option26 = witTypes.Some[string](value25)
+					default:
+						panic("unreachable")
+					}
+
+					option27 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option22, option24, option26})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyS64Type(option27)
+
+			case 6:
+				var option34 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option34 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option29 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option29 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant28 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant28 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant28 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant28 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option29 = witTypes.Some[golem_core_types.NumericBound](variant28)
+					default:
+						panic("unreachable")
+					}
+					var option31 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option31 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant30 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant30 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant30 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant30 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option31 = witTypes.Some[golem_core_types.NumericBound](variant30)
+					default:
+						panic("unreachable")
+					}
+					var option33 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option33 = witTypes.None[string]()
+					case 1:
+						value32 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option33 = witTypes.Some[string](value32)
+					default:
+						panic("unreachable")
+					}
+
+					option34 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option29, option31, option33})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyU8Type(option34)
+
+			case 7:
+				var option41 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option41 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option36 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option36 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant35 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant35 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant35 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant35 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option36 = witTypes.Some[golem_core_types.NumericBound](variant35)
+					default:
+						panic("unreachable")
+					}
+					var option38 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option38 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant37 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant37 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant37 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant37 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option38 = witTypes.Some[golem_core_types.NumericBound](variant37)
+					default:
+						panic("unreachable")
+					}
+					var option40 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option40 = witTypes.None[string]()
+					case 1:
+						value39 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option40 = witTypes.Some[string](value39)
+					default:
+						panic("unreachable")
+					}
+
+					option41 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option36, option38, option40})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyU16Type(option41)
+
+			case 8:
+				var option48 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option48 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option43 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option43 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant42 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant42 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant42 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant42 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option43 = witTypes.Some[golem_core_types.NumericBound](variant42)
+					default:
+						panic("unreachable")
+					}
+					var option45 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option45 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant44 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant44 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant44 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant44 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option45 = witTypes.Some[golem_core_types.NumericBound](variant44)
+					default:
+						panic("unreachable")
+					}
+					var option47 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option47 = witTypes.None[string]()
+					case 1:
+						value46 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option47 = witTypes.Some[string](value46)
+					default:
+						panic("unreachable")
+					}
+
+					option48 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option43, option45, option47})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyU32Type(option48)
+
+			case 9:
+				var option55 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option55 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option50 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option50 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant49 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant49 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant49 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant49 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option50 = witTypes.Some[golem_core_types.NumericBound](variant49)
+					default:
+						panic("unreachable")
+					}
+					var option52 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option52 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant51 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant51 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant51 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant51 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option52 = witTypes.Some[golem_core_types.NumericBound](variant51)
+					default:
+						panic("unreachable")
+					}
+					var option54 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option54 = witTypes.None[string]()
+					case 1:
+						value53 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option54 = witTypes.Some[string](value53)
+					default:
+						panic("unreachable")
+					}
+
+					option55 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option50, option52, option54})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyU64Type(option55)
+
+			case 10:
+				var option62 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option62 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option57 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option57 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant56 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant56 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant56 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant56 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option57 = witTypes.Some[golem_core_types.NumericBound](variant56)
+					default:
+						panic("unreachable")
+					}
+					var option59 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option59 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant58 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant58 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant58 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant58 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option59 = witTypes.Some[golem_core_types.NumericBound](variant58)
+					default:
+						panic("unreachable")
+					}
+					var option61 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option61 = witTypes.None[string]()
+					case 1:
+						value60 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option61 = witTypes.Some[string](value60)
+					default:
+						panic("unreachable")
+					}
+
+					option62 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option57, option59, option61})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyF32Type(option62)
+
+			case 11:
+				var option69 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option69 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option64 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option64 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant63 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant63 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant63 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant63 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option64 = witTypes.Some[golem_core_types.NumericBound](variant63)
+					default:
+						panic("unreachable")
+					}
+					var option66 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option66 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant65 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant65 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant65 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant65 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option66 = witTypes.Some[golem_core_types.NumericBound](variant65)
+					default:
+						panic("unreachable")
+					}
+					var option68 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option68 = witTypes.None[string]()
+					case 1:
+						value67 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option68 = witTypes.Some[string](value67)
+					default:
+						panic("unreachable")
+					}
+
+					option69 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option64, option66, option68})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyF64Type(option69)
+
+			case 12:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+			case 13:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+			case 14:
+				result81 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+					value70 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var option72 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+					case 0:
+
+						option72 = witTypes.None[string]()
+					case 1:
+						value71 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						option72 = witTypes.Some[string](value71)
+					default:
+						panic("unreachable")
+					}
+					result := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+						value73 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result = append(result, value73)
+					}
+
+					result75 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+						value74 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result75 = append(result75, value74)
+					}
+
+					var option77 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+					case 0:
+
+						option77 = witTypes.None[string]()
+					case 1:
+						value76 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+						option77 = witTypes.Some[string](value76)
+					default:
+						panic("unreachable")
+					}
+					var option80 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+					case 0:
+
+						option80 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant79 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+						case 0:
+
+							variant79 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant79 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant79 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value78 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+							variant79 = golem_core_types.MakeRoleOther(value78)
+
+						default:
+							panic("unreachable")
+						}
+
+						option80 = witTypes.Some[golem_core_types.Role](variant79)
+					default:
+						panic("unreachable")
+					}
+
+					result81 = append(result81, golem_core_types.NamedFieldType{value70, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option72, result, result75, option77, option80}})
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyRecordType(result81)
+
+			case 15:
+				result95 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+					value82 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var option83 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+
+						option83 = witTypes.None[int32]()
+					case 1:
+
+						option83 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+					default:
+						panic("unreachable")
+					}
+					var option85 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						option85 = witTypes.None[string]()
+					case 1:
+						value84 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+						option85 = witTypes.Some[string](value84)
+					default:
+						panic("unreachable")
+					}
+					result87 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+						value86 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result87 = append(result87, value86)
+					}
+
+					result89 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+						value88 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result89 = append(result89, value88)
+					}
+
+					var option91 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+					case 0:
+
+						option91 = witTypes.None[string]()
+					case 1:
+						value90 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+						option91 = witTypes.Some[string](value90)
+					default:
+						panic("unreachable")
+					}
+					var option94 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+					case 0:
+
+						option94 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant93 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+						case 0:
+
+							variant93 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant93 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant93 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value92 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+							variant93 = golem_core_types.MakeRoleOther(value92)
+
+						default:
+							panic("unreachable")
+						}
+
+						option94 = witTypes.Some[golem_core_types.Role](variant93)
+					default:
+						panic("unreachable")
+					}
+
+					result95 = append(result95, golem_core_types.VariantCaseType{value82, option83, golem_core_types.MetadataEnvelope{option85, result87, result89, option91, option94}})
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyVariantType(result95)
+
+			case 16:
+				result97 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+					value96 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result97 = append(result97, value96)
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyEnumType(result97)
+
+			case 17:
+				result99 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+					value98 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result99 = append(result99, value98)
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyFlagsType(result99)
+
+			case 18:
+				result100 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result100 = append(result100, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyTupleType(result100)
+
+			case 19:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 20:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+			case 21:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 22:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 23:
+				var option101 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option101 = witTypes.None[int32]()
+				case 1:
+
+					option101 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+				default:
+					panic("unreachable")
+				}
+				var option102 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+				case 0:
+
+					option102 = witTypes.None[int32]()
+				case 1:
+
+					option102 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option101, option102})
+
+			case 24:
+				var option105 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option105 = witTypes.None[[]string]()
+				case 1:
+					result104 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+						value103 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result104 = append(result104, value103)
+					}
+
+					option105 = witTypes.Some[[]string](result104)
+				default:
+					panic("unreachable")
+				}
+				var option106 witTypes.Option[uint32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+				case 0:
+
+					option106 = witTypes.None[uint32]()
+				case 1:
+
+					option106 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+				default:
+					panic("unreachable")
+				}
+				var option107 witTypes.Option[uint32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+				case 0:
+
+					option107 = witTypes.None[uint32]()
+				case 1:
+
+					option107 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+				default:
+					panic("unreachable")
+				}
+				var option109 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+				case 0:
+
+					option109 = witTypes.None[string]()
+				case 1:
+					value108 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+					option109 = witTypes.Some[string](value108)
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option105, option106, option107, option109})
+
+			case 25:
+				var option112 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option112 = witTypes.None[[]string]()
+				case 1:
+					result111 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+						value110 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result111 = append(result111, value110)
+					}
+
+					option112 = witTypes.Some[[]string](result111)
+				default:
+					panic("unreachable")
+				}
+				var option113 witTypes.Option[uint32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+				case 0:
+
+					option113 = witTypes.None[uint32]()
+				case 1:
+
+					option113 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+				default:
+					panic("unreachable")
+				}
+				var option114 witTypes.Option[uint32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+				case 0:
+
+					option114 = witTypes.None[uint32]()
+				case 1:
+
+					option114 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option112, option113, option114})
+
+			case 26:
+				var option117 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+				case 0:
+
+					option117 = witTypes.None[[]string]()
+				case 1:
+					result116 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+						value115 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result116 = append(result116, value115)
+					}
+
+					option117 = witTypes.Some[[]string](result116)
+				default:
+					panic("unreachable")
+				}
+				var option120 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+				case 0:
+
+					option120 = witTypes.None[[]string]()
+				case 1:
+					result119 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+						value118 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result119 = append(result119, value118)
+					}
+
+					option120 = witTypes.Some[[]string](result119)
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option117, option120})
+
+			case 27:
+				var option123 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option123 = witTypes.None[[]string]()
+				case 1:
+					result122 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+						value121 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result122 = append(result122, value121)
+					}
+
+					option123 = witTypes.Some[[]string](result122)
+				default:
+					panic("unreachable")
+				}
+				var option126 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+				case 0:
+
+					option126 = witTypes.None[[]string]()
+				case 1:
+					result125 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+						value124 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result125 = append(result125, value124)
+					}
+
+					option126 = witTypes.Some[[]string](result125)
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option123, option126})
+
+			case 28:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+			case 29:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+			case 30:
+				value127 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				result129 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+					value128 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result129 = append(result129, value128)
+				}
+
+				var option131 witTypes.Option[golem_core_types.QuantityValue]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+				case 0:
+
+					option131 = witTypes.None[golem_core_types.QuantityValue]()
+				case 1:
+					value130 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+					option131 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value130})
+				default:
+					panic("unreachable")
+				}
+				var option133 witTypes.Option[golem_core_types.QuantityValue]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+				case 0:
+
+					option133 = witTypes.None[golem_core_types.QuantityValue]()
+				case 1:
+					value132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+					option133 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value132})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value127, result129, option131, option133})
+
+			case 31:
+				result155 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+					value134 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var variant143 golem_core_types.DiscriminatorRule
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+					case 0:
+						value135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						variant143 = golem_core_types.MakeDiscriminatorRulePrefix(value135)
+
+					case 1:
+						value136 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						variant143 = golem_core_types.MakeDiscriminatorRuleSuffix(value136)
+
+					case 2:
+						value137 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						variant143 = golem_core_types.MakeDiscriminatorRuleContains(value137)
+
+					case 3:
+						value138 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						variant143 = golem_core_types.MakeDiscriminatorRuleRegex(value138)
+
+					case 4:
+						value139 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+						var option141 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+						case 0:
+
+							option141 = witTypes.None[string]()
+						case 1:
+							value140 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+							option141 = witTypes.Some[string](value140)
+						default:
+							panic("unreachable")
+						}
+
+						variant143 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value139, option141})
+
+					case 5:
+						value142 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						variant143 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value142)
+
+					default:
+						panic("unreachable")
+					}
+					var option145 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+					case 0:
+
+						option145 = witTypes.None[string]()
+					case 1:
+						value144 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+						option145 = witTypes.Some[string](value144)
+					default:
+						panic("unreachable")
+					}
+					result147 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+						value146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result147 = append(result147, value146)
+					}
+
+					result149 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+						value148 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result149 = append(result149, value148)
+					}
+
+					var option151 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+					case 0:
+
+						option151 = witTypes.None[string]()
+					case 1:
+						value150 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+						option151 = witTypes.Some[string](value150)
+					default:
+						panic("unreachable")
+					}
+					var option154 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+					case 0:
+
+						option154 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant153 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+						case 0:
+
+							variant153 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant153 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant153 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value152 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+							variant153 = golem_core_types.MakeRoleOther(value152)
+
+						default:
+							panic("unreachable")
+						}
+
+						option154 = witTypes.Some[golem_core_types.Role](variant153)
+					default:
+						panic("unreachable")
+					}
+
+					result155 = append(result155, golem_core_types.UnionBranch{value134, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant143, golem_core_types.MetadataEnvelope{option145, result147, result149, option151, option154}})
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result155})
+
+			case 32:
+				var option157 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+				case 0:
+
+					option157 = witTypes.None[string]()
+				case 1:
+					value156 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+					option157 = witTypes.Some[string](value156)
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option157})
+
+			case 33:
+				var option159 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option159 = witTypes.None[string]()
+				case 1:
+					value158 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+					option159 = witTypes.Some[string](value158)
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option159})
+
+			case 34:
+				var option160 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option160 = witTypes.None[int32]()
+				case 1:
+
+					option160 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyFutureType(option160)
+
+			case 35:
+				var option161 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option161 = witTypes.None[int32]()
+				case 1:
+
+					option161 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyStreamType(option161)
+
+			default:
+				panic("unreachable")
+			}
+			var option164 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+			case 0:
+
+				option164 = witTypes.None[string]()
+			case 1:
+				value163 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+				option164 = witTypes.Some[string](value163)
+			default:
+				panic("unreachable")
+			}
+			result166 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+				value165 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+				result166 = append(result166, value165)
+			}
+
+			result168 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+				value167 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+				result168 = append(result168, value167)
+			}
+
+			var option170 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+			case 0:
+
+				option170 = witTypes.None[string]()
+			case 1:
+				value169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+				option170 = witTypes.Some[string](value169)
+			default:
+				panic("unreachable")
+			}
+			var option173 witTypes.Option[golem_core_types.Role]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+			case 0:
+
+				option173 = witTypes.None[golem_core_types.Role]()
+			case 1:
+				var variant172 golem_core_types.Role
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+				case 0:
+
+					variant172 = golem_core_types.MakeRoleMultimodal()
+
+				case 1:
+
+					variant172 = golem_core_types.MakeRoleUnstructuredText()
+
+				case 2:
+
+					variant172 = golem_core_types.MakeRoleUnstructuredBinary()
+
+				case 3:
+					value171 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+					variant172 = golem_core_types.MakeRoleOther(value171)
+
+				default:
+					panic("unreachable")
+				}
+
+				option173 = witTypes.Some[golem_core_types.Role](variant172)
+			default:
+				panic("unreachable")
+			}
+
+			result174 = append(result174, golem_core_types.SchemaTypeNode{variant162, golem_core_types.MetadataEnvelope{option164, result166, result168, option170, option173}})
+		}
+
+		result178 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(6*4))
+			value175 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			var option177 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+			case 0:
+
+				option177 = witTypes.None[string]()
+			case 1:
+				value176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+				option177 = witTypes.Some[string](value176)
+			default:
+				panic("unreachable")
+			}
+
+			result178 = append(result178, golem_core_types.SchemaTypeDef{value175, option177, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+		}
+
+		var option180 witTypes.Option[string]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) {
+		case 0:
+
+			option180 = witTypes.None[string]()
+		case 1:
+			value179 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+
+			option180 = witTypes.Some[string](value179)
+		default:
+			panic("unreachable")
+		}
+		value181 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+		var option183 witTypes.Option[string]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+		case 0:
+
+			option183 = witTypes.None[string]()
+		case 1:
+			value182 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+			option183 = witTypes.Some[string](value182)
+		default:
+			panic("unreachable")
+		}
+		var variant198 golem_agent_common.InputSchema
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+		case 0:
+			result197 := make([]golem_agent_common.NamedField, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4))))), index*(8+16*4))
+				value184 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+				var variant185 golem_agent_common.FieldSource
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+				case 0:
+
+					variant185 = golem_agent_common.MakeFieldSourceUserSupplied()
+
+				case 1:
+
+					variant185 = golem_agent_common.MakeFieldSourceAutoInjected(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))))))
+
+				default:
+					panic("unreachable")
+				}
+				var option187 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+
+					option187 = witTypes.None[string]()
+				case 1:
+					value186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+					option187 = witTypes.Some[string](value186)
+				default:
+					panic("unreachable")
+				}
+				result189 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+					value188 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result189 = append(result189, value188)
+				}
+
+				result191 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+					value190 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result191 = append(result191, value190)
+				}
+
+				var option193 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+				case 0:
+
+					option193 = witTypes.None[string]()
+				case 1:
+					value192 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+					option193 = witTypes.Some[string](value192)
+				default:
+					panic("unreachable")
+				}
+				var option196 witTypes.Option[golem_core_types.Role]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+				case 0:
+
+					option196 = witTypes.None[golem_core_types.Role]()
+				case 1:
+					var variant195 golem_core_types.Role
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+					case 0:
+
+						variant195 = golem_core_types.MakeRoleMultimodal()
+
+					case 1:
+
+						variant195 = golem_core_types.MakeRoleUnstructuredText()
+
+					case 2:
+
+						variant195 = golem_core_types.MakeRoleUnstructuredBinary()
+
+					case 3:
+						value194 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+						variant195 = golem_core_types.MakeRoleOther(value194)
+
+					default:
+						panic("unreachable")
+					}
+
+					option196 = witTypes.Some[golem_core_types.Role](variant195)
+				default:
+					panic("unreachable")
+				}
+
+				result197 = append(result197, golem_agent_common.NamedField{value184, variant185, *(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))), golem_core_types.MetadataEnvelope{option187, result189, result191, option193, option196}})
+			}
+
+			variant198 = golem_agent_common.MakeInputSchemaParameters(result197)
+
+		default:
+			panic("unreachable")
+		}
+		result238 := make([]golem_agent_common.AgentMethod, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (23 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (23 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))), index*(40+12*4))
+			value199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			value200 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+			result217 := make([]golem_agent_common.HttpEndpointDetails, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))), index*(12*4))
+				var variant202 golem_agent_common.HttpMethod
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant202 = golem_agent_common.MakeHttpMethodGet()
+
+				case 1:
+
+					variant202 = golem_agent_common.MakeHttpMethodHead()
+
+				case 2:
+
+					variant202 = golem_agent_common.MakeHttpMethodPost()
+
+				case 3:
+
+					variant202 = golem_agent_common.MakeHttpMethodPut()
+
+				case 4:
+
+					variant202 = golem_agent_common.MakeHttpMethodDelete()
+
+				case 5:
+
+					variant202 = golem_agent_common.MakeHttpMethodConnect()
+
+				case 6:
+
+					variant202 = golem_agent_common.MakeHttpMethodOptions()
+
+				case 7:
+
+					variant202 = golem_agent_common.MakeHttpMethodTrace()
+
+				case 8:
+
+					variant202 = golem_agent_common.MakeHttpMethodPatch()
+
+				case 9:
+					value201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+					variant202 = golem_agent_common.MakeHttpMethodCustom(value201)
+
+				default:
+					panic("unreachable")
+				}
+				result207 := make([]golem_agent_common.PathSegment, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))), index*(3*4))
+					var variant206 golem_agent_common.PathSegment
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+						value203 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+						variant206 = golem_agent_common.MakePathSegmentLiteral(value203)
+
+					case 1:
+
+						variant206 = golem_agent_common.MakePathSegmentSystemVariable(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))))
+
+					case 2:
+						value204 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+						variant206 = golem_agent_common.MakePathSegmentPathVariable(golem_agent_common.PathVariable{value204})
+
+					case 3:
+						value205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+						variant206 = golem_agent_common.MakePathSegmentRemainingPathVariable(golem_agent_common.PathVariable{value205})
+
+					default:
+						panic("unreachable")
+					}
+
+					result207 = append(result207, variant206)
+				}
+
+				result210 := make([]golem_agent_common.HeaderVariable, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))), index*(4*4))
+					value208 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result210 = append(result210, golem_agent_common.HeaderVariable{value208, value209})
+				}
+
+				result213 := make([]golem_agent_common.QueryVariable, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))), index*(4*4))
+					value211 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value212 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result213 = append(result213, golem_agent_common.QueryVariable{value211, value212})
+				}
+
+				var option214 witTypes.Option[golem_agent_common.AuthDetails]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+				case 0:
+
+					option214 = witTypes.None[golem_agent_common.AuthDetails]()
+				case 1:
+
+					option214 = witTypes.Some[golem_agent_common.AuthDetails](golem_agent_common.AuthDetails{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (1 + 9*4)))) != 0)})
+				default:
+					panic("unreachable")
+				}
+				result216 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))))), index*(2*4))
+					value215 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result216 = append(result216, value215)
+				}
+
+				result217 = append(result217, golem_agent_common.HttpEndpointDetails{variant202, result207, result210, result213, option214, golem_agent_common.CorsOptions{result216}})
+			}
+
+			var option219 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+			case 0:
+
+				option219 = witTypes.None[string]()
+			case 1:
+				value218 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+				option219 = witTypes.Some[string](value218)
+			default:
+				panic("unreachable")
+			}
+			var variant234 golem_agent_common.InputSchema
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+			case 0:
+				result233 := make([]golem_agent_common.NamedField, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))))), index*(8+16*4))
+					value220 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var variant221 golem_agent_common.FieldSource
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+
+						variant221 = golem_agent_common.MakeFieldSourceUserSupplied()
+
+					case 1:
+
+						variant221 = golem_agent_common.MakeFieldSourceAutoInjected(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))))))
+
+					default:
+						panic("unreachable")
+					}
+					var option223 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						option223 = witTypes.None[string]()
+					case 1:
+						value222 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+						option223 = witTypes.Some[string](value222)
+					default:
+						panic("unreachable")
+					}
+					result225 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+						value224 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result225 = append(result225, value224)
+					}
+
+					result227 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+						value226 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result227 = append(result227, value226)
+					}
+
+					var option229 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+					case 0:
+
+						option229 = witTypes.None[string]()
+					case 1:
+						value228 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+						option229 = witTypes.Some[string](value228)
+					default:
+						panic("unreachable")
+					}
+					var option232 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+					case 0:
+
+						option232 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant231 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+						case 0:
+
+							variant231 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant231 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant231 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value230 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+							variant231 = golem_core_types.MakeRoleOther(value230)
+
+						default:
+							panic("unreachable")
+						}
+
+						option232 = witTypes.Some[golem_core_types.Role](variant231)
+					default:
+						panic("unreachable")
+					}
+
+					result233 = append(result233, golem_agent_common.NamedField{value220, variant221, *(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))), golem_core_types.MetadataEnvelope{option223, result225, result227, option229, option232}})
+				}
+
+				variant234 = golem_agent_common.MakeInputSchemaParameters(result233)
+
+			default:
+				panic("unreachable")
+			}
+			var variant235 golem_agent_common.OutputSchema
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) {
+			case 0:
+
+				variant235 = golem_agent_common.MakeOutputSchemaUnit()
+
+			case 1:
+
+				variant235 = golem_agent_common.MakeOutputSchemaSingle(*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 12*4))))
+
+			default:
+				panic("unreachable")
+			}
+			var option237 witTypes.Option[golem_agent_common.ReadOnlyConfig]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+			case 0:
+
+				option237 = witTypes.None[golem_agent_common.ReadOnlyConfig]()
+			case 1:
+				var variant236 golem_agent_common.CachePolicy
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4)))) {
+				case 0:
+
+					variant236 = golem_agent_common.MakeCachePolicyNoCache()
+
+				case 1:
+
+					variant236 = golem_agent_common.MakeCachePolicyUntilWrite()
+
+				case 2:
+
+					variant236 = golem_agent_common.MakeCachePolicyTtl(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 12*4)))))
+
+				default:
+					panic("unreachable")
+				}
+
+				option237 = witTypes.Some[golem_agent_common.ReadOnlyConfig](golem_agent_common.ReadOnlyConfig{variant236, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4)))) != 0)})
+			default:
+				panic("unreachable")
+			}
+
+			result238 = append(result238, golem_agent_common.AgentMethod{value199, value200, result217, option219, variant234, variant235, option237})
+		}
+
+		result482 := make([]golem_agent_common.AgentDependency, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (25 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (25 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 * 4))))), index*(23*4))
+			value239 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			var option241 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+			case 0:
+
+				option241 = witTypes.None[string]()
+			case 1:
+				value240 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+				option241 = witTypes.Some[string](value240)
+			default:
+				panic("unreachable")
+			}
+			result417 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))), index*(56+22*4))
+				var variant405 golem_core_types.SchemaTypeBody
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 1:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+				case 2:
+					var option248 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option248 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option243 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option243 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant242 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant242 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant242 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant242 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option243 = witTypes.Some[golem_core_types.NumericBound](variant242)
+						default:
+							panic("unreachable")
+						}
+						var option245 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option245 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant244 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant244 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant244 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant244 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option245 = witTypes.Some[golem_core_types.NumericBound](variant244)
+						default:
+							panic("unreachable")
+						}
+						var option247 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option247 = witTypes.None[string]()
+						case 1:
+							value246 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option247 = witTypes.Some[string](value246)
+						default:
+							panic("unreachable")
+						}
+
+						option248 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option243, option245, option247})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyS8Type(option248)
+
+				case 3:
+					var option255 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option255 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option250 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option250 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant249 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant249 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant249 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant249 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option250 = witTypes.Some[golem_core_types.NumericBound](variant249)
+						default:
+							panic("unreachable")
+						}
+						var option252 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option252 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant251 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant251 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant251 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant251 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option252 = witTypes.Some[golem_core_types.NumericBound](variant251)
+						default:
+							panic("unreachable")
+						}
+						var option254 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option254 = witTypes.None[string]()
+						case 1:
+							value253 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option254 = witTypes.Some[string](value253)
+						default:
+							panic("unreachable")
+						}
+
+						option255 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option250, option252, option254})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyS16Type(option255)
+
+				case 4:
+					var option262 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option262 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option257 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option257 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant256 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant256 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant256 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant256 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option257 = witTypes.Some[golem_core_types.NumericBound](variant256)
+						default:
+							panic("unreachable")
+						}
+						var option259 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option259 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant258 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant258 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant258 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant258 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option259 = witTypes.Some[golem_core_types.NumericBound](variant258)
+						default:
+							panic("unreachable")
+						}
+						var option261 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option261 = witTypes.None[string]()
+						case 1:
+							value260 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option261 = witTypes.Some[string](value260)
+						default:
+							panic("unreachable")
+						}
+
+						option262 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option257, option259, option261})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyS32Type(option262)
+
+				case 5:
+					var option269 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option269 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option264 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option264 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant263 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant263 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant263 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant263 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option264 = witTypes.Some[golem_core_types.NumericBound](variant263)
+						default:
+							panic("unreachable")
+						}
+						var option266 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option266 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant265 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant265 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant265 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant265 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option266 = witTypes.Some[golem_core_types.NumericBound](variant265)
+						default:
+							panic("unreachable")
+						}
+						var option268 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option268 = witTypes.None[string]()
+						case 1:
+							value267 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option268 = witTypes.Some[string](value267)
+						default:
+							panic("unreachable")
+						}
+
+						option269 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option264, option266, option268})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyS64Type(option269)
+
+				case 6:
+					var option276 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option276 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option271 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option271 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant270 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant270 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant270 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant270 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option271 = witTypes.Some[golem_core_types.NumericBound](variant270)
+						default:
+							panic("unreachable")
+						}
+						var option273 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option273 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant272 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant272 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant272 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant272 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option273 = witTypes.Some[golem_core_types.NumericBound](variant272)
+						default:
+							panic("unreachable")
+						}
+						var option275 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option275 = witTypes.None[string]()
+						case 1:
+							value274 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option275 = witTypes.Some[string](value274)
+						default:
+							panic("unreachable")
+						}
+
+						option276 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option271, option273, option275})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyU8Type(option276)
+
+				case 7:
+					var option283 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option283 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option278 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option278 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant277 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant277 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant277 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant277 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option278 = witTypes.Some[golem_core_types.NumericBound](variant277)
+						default:
+							panic("unreachable")
+						}
+						var option280 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option280 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant279 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant279 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant279 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant279 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option280 = witTypes.Some[golem_core_types.NumericBound](variant279)
+						default:
+							panic("unreachable")
+						}
+						var option282 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option282 = witTypes.None[string]()
+						case 1:
+							value281 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option282 = witTypes.Some[string](value281)
+						default:
+							panic("unreachable")
+						}
+
+						option283 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option278, option280, option282})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyU16Type(option283)
+
+				case 8:
+					var option290 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option290 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option285 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option285 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant284 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant284 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant284 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant284 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option285 = witTypes.Some[golem_core_types.NumericBound](variant284)
+						default:
+							panic("unreachable")
+						}
+						var option287 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option287 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant286 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant286 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant286 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant286 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option287 = witTypes.Some[golem_core_types.NumericBound](variant286)
+						default:
+							panic("unreachable")
+						}
+						var option289 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option289 = witTypes.None[string]()
+						case 1:
+							value288 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option289 = witTypes.Some[string](value288)
+						default:
+							panic("unreachable")
+						}
+
+						option290 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option285, option287, option289})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyU32Type(option290)
+
+				case 9:
+					var option297 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option297 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option292 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option292 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant291 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant291 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant291 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant291 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option292 = witTypes.Some[golem_core_types.NumericBound](variant291)
+						default:
+							panic("unreachable")
+						}
+						var option294 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option294 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant293 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant293 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant293 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant293 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option294 = witTypes.Some[golem_core_types.NumericBound](variant293)
+						default:
+							panic("unreachable")
+						}
+						var option296 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option296 = witTypes.None[string]()
+						case 1:
+							value295 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option296 = witTypes.Some[string](value295)
+						default:
+							panic("unreachable")
+						}
+
+						option297 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option292, option294, option296})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyU64Type(option297)
+
+				case 10:
+					var option304 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option304 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option299 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option299 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant298 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant298 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant298 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant298 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option299 = witTypes.Some[golem_core_types.NumericBound](variant298)
+						default:
+							panic("unreachable")
+						}
+						var option301 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option301 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant300 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant300 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant300 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant300 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option301 = witTypes.Some[golem_core_types.NumericBound](variant300)
+						default:
+							panic("unreachable")
+						}
+						var option303 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option303 = witTypes.None[string]()
+						case 1:
+							value302 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option303 = witTypes.Some[string](value302)
+						default:
+							panic("unreachable")
+						}
+
+						option304 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option299, option301, option303})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyF32Type(option304)
+
+				case 11:
+					var option311 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option311 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option306 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option306 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant305 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant305 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant305 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant305 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option306 = witTypes.Some[golem_core_types.NumericBound](variant305)
+						default:
+							panic("unreachable")
+						}
+						var option308 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option308 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant307 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant307 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant307 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant307 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option308 = witTypes.Some[golem_core_types.NumericBound](variant307)
+						default:
+							panic("unreachable")
+						}
+						var option310 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option310 = witTypes.None[string]()
+						case 1:
+							value309 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option310 = witTypes.Some[string](value309)
+						default:
+							panic("unreachable")
+						}
+
+						option311 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option306, option308, option310})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyF64Type(option311)
+
+				case 12:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+				case 13:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+				case 14:
+					result324 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+						value312 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option314 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+						case 0:
+
+							option314 = witTypes.None[string]()
+						case 1:
+							value313 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							option314 = witTypes.Some[string](value313)
+						default:
+							panic("unreachable")
+						}
+						result316 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+							value315 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result316 = append(result316, value315)
+						}
+
+						result318 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+							value317 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result318 = append(result318, value317)
+						}
+
+						var option320 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+						case 0:
+
+							option320 = witTypes.None[string]()
+						case 1:
+							value319 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+							option320 = witTypes.Some[string](value319)
+						default:
+							panic("unreachable")
+						}
+						var option323 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+						case 0:
+
+							option323 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant322 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+							case 0:
+
+								variant322 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant322 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant322 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value321 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+								variant322 = golem_core_types.MakeRoleOther(value321)
+
+							default:
+								panic("unreachable")
+							}
+
+							option323 = witTypes.Some[golem_core_types.Role](variant322)
+						default:
+							panic("unreachable")
+						}
+
+						result324 = append(result324, golem_core_types.NamedFieldType{value312, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option314, result316, result318, option320, option323}})
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyRecordType(result324)
+
+				case 15:
+					result338 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+						value325 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option326 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option326 = witTypes.None[int32]()
+						case 1:
+
+							option326 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+						default:
+							panic("unreachable")
+						}
+						var option328 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option328 = witTypes.None[string]()
+						case 1:
+							value327 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option328 = witTypes.Some[string](value327)
+						default:
+							panic("unreachable")
+						}
+						result330 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+							value329 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result330 = append(result330, value329)
+						}
+
+						result332 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+							value331 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result332 = append(result332, value331)
+						}
+
+						var option334 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+						case 0:
+
+							option334 = witTypes.None[string]()
+						case 1:
+							value333 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+							option334 = witTypes.Some[string](value333)
+						default:
+							panic("unreachable")
+						}
+						var option337 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+						case 0:
+
+							option337 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant336 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+							case 0:
+
+								variant336 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant336 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant336 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value335 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+								variant336 = golem_core_types.MakeRoleOther(value335)
+
+							default:
+								panic("unreachable")
+							}
+
+							option337 = witTypes.Some[golem_core_types.Role](variant336)
+						default:
+							panic("unreachable")
+						}
+
+						result338 = append(result338, golem_core_types.VariantCaseType{value325, option326, golem_core_types.MetadataEnvelope{option328, result330, result332, option334, option337}})
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyVariantType(result338)
+
+				case 16:
+					result340 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+						value339 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result340 = append(result340, value339)
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyEnumType(result340)
+
+				case 17:
+					result342 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+						value341 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result342 = append(result342, value341)
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyFlagsType(result342)
+
+				case 18:
+					result343 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result343 = append(result343, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyTupleType(result343)
+
+				case 19:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 20:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+				case 21:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+				case 22:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 23:
+					var option344 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option344 = witTypes.None[int32]()
+					case 1:
+
+						option344 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+					var option345 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option345 = witTypes.None[int32]()
+					case 1:
+
+						option345 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option344, option345})
+
+				case 24:
+					var option348 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option348 = witTypes.None[[]string]()
+					case 1:
+						result347 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+							value346 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result347 = append(result347, value346)
+						}
+
+						option348 = witTypes.Some[[]string](result347)
+					default:
+						panic("unreachable")
+					}
+					var option349 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+					case 0:
+
+						option349 = witTypes.None[uint32]()
+					case 1:
+
+						option349 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+					var option350 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+					case 0:
+
+						option350 = witTypes.None[uint32]()
+					case 1:
+
+						option350 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+					var option352 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+					case 0:
+
+						option352 = witTypes.None[string]()
+					case 1:
+						value351 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+						option352 = witTypes.Some[string](value351)
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option348, option349, option350, option352})
+
+				case 25:
+					var option355 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option355 = witTypes.None[[]string]()
+					case 1:
+						result354 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+							value353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result354 = append(result354, value353)
+						}
+
+						option355 = witTypes.Some[[]string](result354)
+					default:
+						panic("unreachable")
+					}
+					var option356 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+					case 0:
+
+						option356 = witTypes.None[uint32]()
+					case 1:
+
+						option356 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+					var option357 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+					case 0:
+
+						option357 = witTypes.None[uint32]()
+					case 1:
+
+						option357 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option355, option356, option357})
+
+				case 26:
+					var option360 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+					case 0:
+
+						option360 = witTypes.None[[]string]()
+					case 1:
+						result359 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+							value358 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result359 = append(result359, value358)
+						}
+
+						option360 = witTypes.Some[[]string](result359)
+					default:
+						panic("unreachable")
+					}
+					var option363 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+					case 0:
+
+						option363 = witTypes.None[[]string]()
+					case 1:
+						result362 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+							value361 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result362 = append(result362, value361)
+						}
+
+						option363 = witTypes.Some[[]string](result362)
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option360, option363})
+
+				case 27:
+					var option366 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option366 = witTypes.None[[]string]()
+					case 1:
+						result365 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+							value364 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result365 = append(result365, value364)
+						}
+
+						option366 = witTypes.Some[[]string](result365)
+					default:
+						panic("unreachable")
+					}
+					var option369 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+					case 0:
+
+						option369 = witTypes.None[[]string]()
+					case 1:
+						result368 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+							value367 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result368 = append(result368, value367)
+						}
+
+						option369 = witTypes.Some[[]string](result368)
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option366, option369})
+
+				case 28:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+				case 29:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+				case 30:
+					value370 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					result372 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+						value371 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result372 = append(result372, value371)
+					}
+
+					var option374 witTypes.Option[golem_core_types.QuantityValue]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+					case 0:
+
+						option374 = witTypes.None[golem_core_types.QuantityValue]()
+					case 1:
+						value373 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+						option374 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value373})
+					default:
+						panic("unreachable")
+					}
+					var option376 witTypes.Option[golem_core_types.QuantityValue]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+					case 0:
+
+						option376 = witTypes.None[golem_core_types.QuantityValue]()
+					case 1:
+						value375 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+						option376 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value375})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value370, result372, option374, option376})
+
+				case 31:
+					result398 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+						value377 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var variant386 golem_core_types.DiscriminatorRule
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+						case 0:
+							value378 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant386 = golem_core_types.MakeDiscriminatorRulePrefix(value378)
+
+						case 1:
+							value379 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant386 = golem_core_types.MakeDiscriminatorRuleSuffix(value379)
+
+						case 2:
+							value380 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant386 = golem_core_types.MakeDiscriminatorRuleContains(value380)
+
+						case 3:
+							value381 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant386 = golem_core_types.MakeDiscriminatorRuleRegex(value381)
+
+						case 4:
+							value382 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+							var option384 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+							case 0:
+
+								option384 = witTypes.None[string]()
+							case 1:
+								value383 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+								option384 = witTypes.Some[string](value383)
+							default:
+								panic("unreachable")
+							}
+
+							variant386 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value382, option384})
+
+						case 5:
+							value385 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant386 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value385)
+
+						default:
+							panic("unreachable")
+						}
+						var option388 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+						case 0:
+
+							option388 = witTypes.None[string]()
+						case 1:
+							value387 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+							option388 = witTypes.Some[string](value387)
+						default:
+							panic("unreachable")
+						}
+						result390 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+							value389 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result390 = append(result390, value389)
+						}
+
+						result392 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+							value391 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result392 = append(result392, value391)
+						}
+
+						var option394 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+						case 0:
+
+							option394 = witTypes.None[string]()
+						case 1:
+							value393 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+							option394 = witTypes.Some[string](value393)
+						default:
+							panic("unreachable")
+						}
+						var option397 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+						case 0:
+
+							option397 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant396 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+							case 0:
+
+								variant396 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant396 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant396 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value395 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+								variant396 = golem_core_types.MakeRoleOther(value395)
+
+							default:
+								panic("unreachable")
+							}
+
+							option397 = witTypes.Some[golem_core_types.Role](variant396)
+						default:
+							panic("unreachable")
+						}
+
+						result398 = append(result398, golem_core_types.UnionBranch{value377, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant386, golem_core_types.MetadataEnvelope{option388, result390, result392, option394, option397}})
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result398})
+
+				case 32:
+					var option400 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+					case 0:
+
+						option400 = witTypes.None[string]()
+					case 1:
+						value399 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						option400 = witTypes.Some[string](value399)
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option400})
+
+				case 33:
+					var option402 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option402 = witTypes.None[string]()
+					case 1:
+						value401 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+						option402 = witTypes.Some[string](value401)
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option402})
+
+				case 34:
+					var option403 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option403 = witTypes.None[int32]()
+					case 1:
+
+						option403 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyFutureType(option403)
+
+				case 35:
+					var option404 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option404 = witTypes.None[int32]()
+					case 1:
+
+						option404 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyStreamType(option404)
+
+				default:
+					panic("unreachable")
+				}
+				var option407 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+				case 0:
+
+					option407 = witTypes.None[string]()
+				case 1:
+					value406 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+					option407 = witTypes.Some[string](value406)
+				default:
+					panic("unreachable")
+				}
+				result409 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+					value408 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result409 = append(result409, value408)
+				}
+
+				result411 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+					value410 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result411 = append(result411, value410)
+				}
+
+				var option413 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+				case 0:
+
+					option413 = witTypes.None[string]()
+				case 1:
+					value412 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+					option413 = witTypes.Some[string](value412)
+				default:
+					panic("unreachable")
+				}
+				var option416 witTypes.Option[golem_core_types.Role]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+				case 0:
+
+					option416 = witTypes.None[golem_core_types.Role]()
+				case 1:
+					var variant415 golem_core_types.Role
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+					case 0:
+
+						variant415 = golem_core_types.MakeRoleMultimodal()
+
+					case 1:
+
+						variant415 = golem_core_types.MakeRoleUnstructuredText()
+
+					case 2:
+
+						variant415 = golem_core_types.MakeRoleUnstructuredBinary()
+
+					case 3:
+						value414 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+						variant415 = golem_core_types.MakeRoleOther(value414)
+
+					default:
+						panic("unreachable")
+					}
+
+					option416 = witTypes.Some[golem_core_types.Role](variant415)
+				default:
+					panic("unreachable")
+				}
+
+				result417 = append(result417, golem_core_types.SchemaTypeNode{variant405, golem_core_types.MetadataEnvelope{option407, result409, result411, option413, option416}})
+			}
+
+			result421 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))), index*(6*4))
+				value418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+				var option420 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+				case 0:
+
+					option420 = witTypes.None[string]()
+				case 1:
+					value419 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+					option420 = witTypes.Some[string](value419)
+				default:
+					panic("unreachable")
+				}
+
+				result421 = append(result421, golem_core_types.SchemaTypeDef{value418, option420, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+			}
+
+			var option423 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+			case 0:
+
+				option423 = witTypes.None[string]()
+			case 1:
+				value422 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+				option423 = witTypes.Some[string](value422)
+			default:
+				panic("unreachable")
+			}
+			value424 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))
+			var option426 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))) {
+			case 0:
+
+				option426 = witTypes.None[string]()
+			case 1:
+				value425 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))))
+
+				option426 = witTypes.Some[string](value425)
+			default:
+				panic("unreachable")
+			}
+			var variant441 golem_agent_common.InputSchema
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) {
+			case 0:
+				result440 := make([]golem_agent_common.NamedField, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4))))), index*(8+16*4))
+					value427 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var variant428 golem_agent_common.FieldSource
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+
+						variant428 = golem_agent_common.MakeFieldSourceUserSupplied()
+
+					case 1:
+
+						variant428 = golem_agent_common.MakeFieldSourceAutoInjected(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))))))
+
+					default:
+						panic("unreachable")
+					}
+					var option430 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						option430 = witTypes.None[string]()
+					case 1:
+						value429 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+						option430 = witTypes.Some[string](value429)
+					default:
+						panic("unreachable")
+					}
+					result432 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+						value431 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result432 = append(result432, value431)
+					}
+
+					result434 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+						value433 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result434 = append(result434, value433)
+					}
+
+					var option436 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+					case 0:
+
+						option436 = witTypes.None[string]()
+					case 1:
+						value435 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+						option436 = witTypes.Some[string](value435)
+					default:
+						panic("unreachable")
+					}
+					var option439 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+					case 0:
+
+						option439 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant438 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+						case 0:
+
+							variant438 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant438 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant438 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value437 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+							variant438 = golem_core_types.MakeRoleOther(value437)
+
+						default:
+							panic("unreachable")
+						}
+
+						option439 = witTypes.Some[golem_core_types.Role](variant438)
+					default:
+						panic("unreachable")
+					}
+
+					result440 = append(result440, golem_agent_common.NamedField{value427, variant428, *(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))), golem_core_types.MetadataEnvelope{option430, result432, result434, option436, option439}})
+				}
+
+				variant441 = golem_agent_common.MakeInputSchemaParameters(result440)
+
+			default:
+				panic("unreachable")
+			}
+			result481 := make([]golem_agent_common.AgentMethod, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))))), index*(40+12*4))
+				value442 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+				value443 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+				result460 := make([]golem_agent_common.HttpEndpointDetails, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))), index*(12*4))
+					var variant445 golem_agent_common.HttpMethod
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant445 = golem_agent_common.MakeHttpMethodGet()
+
+					case 1:
+
+						variant445 = golem_agent_common.MakeHttpMethodHead()
+
+					case 2:
+
+						variant445 = golem_agent_common.MakeHttpMethodPost()
+
+					case 3:
+
+						variant445 = golem_agent_common.MakeHttpMethodPut()
+
+					case 4:
+
+						variant445 = golem_agent_common.MakeHttpMethodDelete()
+
+					case 5:
+
+						variant445 = golem_agent_common.MakeHttpMethodConnect()
+
+					case 6:
+
+						variant445 = golem_agent_common.MakeHttpMethodOptions()
+
+					case 7:
+
+						variant445 = golem_agent_common.MakeHttpMethodTrace()
+
+					case 8:
+
+						variant445 = golem_agent_common.MakeHttpMethodPatch()
+
+					case 9:
+						value444 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+						variant445 = golem_agent_common.MakeHttpMethodCustom(value444)
+
+					default:
+						panic("unreachable")
+					}
+					result450 := make([]golem_agent_common.PathSegment, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))), index*(3*4))
+						var variant449 golem_agent_common.PathSegment
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+							value446 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+							variant449 = golem_agent_common.MakePathSegmentLiteral(value446)
+
+						case 1:
+
+							variant449 = golem_agent_common.MakePathSegmentSystemVariable(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))))
+
+						case 2:
+							value447 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+							variant449 = golem_agent_common.MakePathSegmentPathVariable(golem_agent_common.PathVariable{value447})
+
+						case 3:
+							value448 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+							variant449 = golem_agent_common.MakePathSegmentRemainingPathVariable(golem_agent_common.PathVariable{value448})
+
+						default:
+							panic("unreachable")
+						}
+
+						result450 = append(result450, variant449)
+					}
+
+					result453 := make([]golem_agent_common.HeaderVariable, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))), index*(4*4))
+						value451 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						value452 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+						result453 = append(result453, golem_agent_common.HeaderVariable{value451, value452})
+					}
+
+					result456 := make([]golem_agent_common.QueryVariable, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))), index*(4*4))
+						value454 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						value455 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+						result456 = append(result456, golem_agent_common.QueryVariable{value454, value455})
+					}
+
+					var option457 witTypes.Option[golem_agent_common.AuthDetails]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+					case 0:
+
+						option457 = witTypes.None[golem_agent_common.AuthDetails]()
+					case 1:
+
+						option457 = witTypes.Some[golem_agent_common.AuthDetails](golem_agent_common.AuthDetails{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (1 + 9*4)))) != 0)})
+					default:
+						panic("unreachable")
+					}
+					result459 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))))), index*(2*4))
+						value458 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result459 = append(result459, value458)
+					}
+
+					result460 = append(result460, golem_agent_common.HttpEndpointDetails{variant445, result450, result453, result456, option457, golem_agent_common.CorsOptions{result459}})
+				}
+
+				var option462 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+				case 0:
+
+					option462 = witTypes.None[string]()
+				case 1:
+					value461 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+					option462 = witTypes.Some[string](value461)
+				default:
+					panic("unreachable")
+				}
+				var variant477 golem_agent_common.InputSchema
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+				case 0:
+					result476 := make([]golem_agent_common.NamedField, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))))), index*(8+16*4))
+						value463 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var variant464 golem_agent_common.FieldSource
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							variant464 = golem_agent_common.MakeFieldSourceUserSupplied()
+
+						case 1:
+
+							variant464 = golem_agent_common.MakeFieldSourceAutoInjected(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))))))
+
+						default:
+							panic("unreachable")
+						}
+						var option466 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option466 = witTypes.None[string]()
+						case 1:
+							value465 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option466 = witTypes.Some[string](value465)
+						default:
+							panic("unreachable")
+						}
+						result468 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+							value467 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result468 = append(result468, value467)
+						}
+
+						result470 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+							value469 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result470 = append(result470, value469)
+						}
+
+						var option472 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+						case 0:
+
+							option472 = witTypes.None[string]()
+						case 1:
+							value471 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+							option472 = witTypes.Some[string](value471)
+						default:
+							panic("unreachable")
+						}
+						var option475 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+						case 0:
+
+							option475 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant474 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+							case 0:
+
+								variant474 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant474 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant474 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value473 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+								variant474 = golem_core_types.MakeRoleOther(value473)
+
+							default:
+								panic("unreachable")
+							}
+
+							option475 = witTypes.Some[golem_core_types.Role](variant474)
+						default:
+							panic("unreachable")
+						}
+
+						result476 = append(result476, golem_agent_common.NamedField{value463, variant464, *(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))), golem_core_types.MetadataEnvelope{option466, result468, result470, option472, option475}})
+					}
+
+					variant477 = golem_agent_common.MakeInputSchemaParameters(result476)
+
+				default:
+					panic("unreachable")
+				}
+				var variant478 golem_agent_common.OutputSchema
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) {
+				case 0:
+
+					variant478 = golem_agent_common.MakeOutputSchemaUnit()
+
+				case 1:
+
+					variant478 = golem_agent_common.MakeOutputSchemaSingle(*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 12*4))))
+
+				default:
+					panic("unreachable")
+				}
+				var option480 witTypes.Option[golem_agent_common.ReadOnlyConfig]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+				case 0:
+
+					option480 = witTypes.None[golem_agent_common.ReadOnlyConfig]()
+				case 1:
+					var variant479 golem_agent_common.CachePolicy
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4)))) {
+					case 0:
+
+						variant479 = golem_agent_common.MakeCachePolicyNoCache()
+
+					case 1:
+
+						variant479 = golem_agent_common.MakeCachePolicyUntilWrite()
+
+					case 2:
+
+						variant479 = golem_agent_common.MakeCachePolicyTtl(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 12*4)))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option480 = witTypes.Some[golem_agent_common.ReadOnlyConfig](golem_agent_common.ReadOnlyConfig{variant479, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4)))) != 0)})
+				default:
+					panic("unreachable")
+				}
+
+				result481 = append(result481, golem_agent_common.AgentMethod{value442, value443, result460, option462, variant477, variant478, option480})
+			}
+
+			result482 = append(result482, golem_agent_common.AgentDependency{value239, option241, golem_core_types.SchemaGraph{result417, result421, *(*int32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))}, golem_agent_common.AgentConstructor{option423, value424, option426, variant441}, result481})
+		}
+
+		var option496 witTypes.Option[golem_agent_common.HttpMountDetails]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (27 * 4)))) {
+		case 0:
+
+			option496 = witTypes.None[golem_agent_common.HttpMountDetails]()
+		case 1:
+			result487 := make([]golem_agent_common.PathSegment, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (29 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (29 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (28 * 4))))), index*(3*4))
+				var variant486 golem_agent_common.PathSegment
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+					value483 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+					variant486 = golem_agent_common.MakePathSegmentLiteral(value483)
+
+				case 1:
+
+					variant486 = golem_agent_common.MakePathSegmentSystemVariable(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))))
+
+				case 2:
+					value484 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+					variant486 = golem_agent_common.MakePathSegmentPathVariable(golem_agent_common.PathVariable{value484})
+
+				case 3:
+					value485 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+					variant486 = golem_agent_common.MakePathSegmentRemainingPathVariable(golem_agent_common.PathVariable{value485})
+
+				default:
+					panic("unreachable")
+				}
+
+				result487 = append(result487, variant486)
+			}
+
+			var option488 witTypes.Option[golem_agent_common.AuthDetails]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (30 * 4)))) {
+			case 0:
+
+				option488 = witTypes.None[golem_agent_common.AuthDetails]()
+			case 1:
+
+				option488 = witTypes.Some[golem_agent_common.AuthDetails](golem_agent_common.AuthDetails{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (1 + 30*4)))) != 0)})
+			default:
+				panic("unreachable")
+			}
+			result490 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (31 * 4))))), index*(2*4))
+				value489 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+				result490 = append(result490, value489)
+			}
+
+			result495 := make([]golem_agent_common.PathSegment, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (34 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (34 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (33 * 4))))), index*(3*4))
+				var variant494 golem_agent_common.PathSegment
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+					value491 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+					variant494 = golem_agent_common.MakePathSegmentLiteral(value491)
+
+				case 1:
+
+					variant494 = golem_agent_common.MakePathSegmentSystemVariable(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))))
+
+				case 2:
+					value492 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+					variant494 = golem_agent_common.MakePathSegmentPathVariable(golem_agent_common.PathVariable{value492})
+
+				case 3:
+					value493 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+					variant494 = golem_agent_common.MakePathSegmentRemainingPathVariable(golem_agent_common.PathVariable{value493})
+
+				default:
+					panic("unreachable")
+				}
+
+				result495 = append(result495, variant494)
+			}
+
+			option496 = witTypes.Some[golem_agent_common.HttpMountDetails](golem_agent_common.HttpMountDetails{result487, option488, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 + 30*4)))) != 0), golem_agent_common.CorsOptions{result490}, result495})
+		default:
+			panic("unreachable")
+		}
+		var variant498 golem_agent_common.Snapshotting
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 34*4)))) {
+		case 0:
+
+			variant498 = golem_agent_common.MakeSnapshottingDisabled()
+
+		case 1:
+			var variant497 golem_agent_common.SnapshottingConfig
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 34*4)))) {
+			case 0:
+
+				variant497 = golem_agent_common.MakeSnapshottingConfigDefault()
+
+			case 1:
+
+				variant497 = golem_agent_common.MakeSnapshottingConfigPeriodic(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 34*4)))))
+
+			case 2:
+
+				variant497 = golem_agent_common.MakeSnapshottingConfigEveryNInvocation(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 34*4))))))
+
+			default:
+				panic("unreachable")
+			}
+
+			variant498 = golem_agent_common.MakeSnapshottingEnabled(variant497)
+
+		default:
+			panic("unreachable")
+		}
+		result501 := make([]golem_agent_common.AgentConfigDeclaration, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 35*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 35*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 34*4))))), index*(4*4))
+			result500 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))), index*(2*4))
+				value499 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+				result500 = append(result500, value499)
+			}
+
+			result501 = append(result501, golem_agent_common.AgentConfigDeclaration{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), result500, *(*int32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))})
+		}
+
+		result502 = append(result502, golem_agent_common.RegisteredAgentType{golem_agent_common.AgentType{value, value0, value1, golem_core_types.SchemaGraph{result174, result178, *(*int32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))}, golem_agent_common.AgentConstructor{option180, value181, option183, variant198}, result238, result482, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (26 * 4))))), option496, variant498, result501}, golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (32 + 36*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 36*4))))}}})
+	}
+
+	result503 := result502
+	return result503
+
+}
+
+//go:wasmimport golem:agent/host@2.0.0 get-agent-type
+func wasm_import_get_agent_type(arg0 uintptr, arg1 uint32, arg2 uintptr)
+
+func GetAgentType(agentTypeName string) witTypes.Option[golem_agent_common.RegisteredAgentType] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (56 + 36*4), 8))
+	utf8 := unsafe.Pointer(unsafe.StringData(agentTypeName))
+	pinner.Pin(utf8)
+	wasm_import_get_agent_type(uintptr(utf8), uint32(len(agentTypeName)), returnArea)
+	var option502 witTypes.Option[golem_agent_common.RegisteredAgentType]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option502 = witTypes.None[golem_agent_common.RegisteredAgentType]()
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+		value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4))))
+		value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 5*4))))
+		result174 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 7*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 7*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 6*4))))), index*(56+22*4))
+			var variant162 golem_core_types.SchemaTypeBody
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 1:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+			case 2:
+				var option6 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option6 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option = witTypes.Some[golem_core_types.NumericBound](variant)
+					default:
+						panic("unreachable")
+					}
+					var option3 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option3 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant2 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant2 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant2 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant2 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option3 = witTypes.Some[golem_core_types.NumericBound](variant2)
+					default:
+						panic("unreachable")
+					}
+					var option5 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option5 = witTypes.None[string]()
+					case 1:
+						value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option5 = witTypes.Some[string](value4)
+					default:
+						panic("unreachable")
+					}
+
+					option6 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option, option3, option5})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyS8Type(option6)
+
+			case 3:
+				var option13 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option13 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option8 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option8 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant7 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant7 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant7 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant7 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option8 = witTypes.Some[golem_core_types.NumericBound](variant7)
+					default:
+						panic("unreachable")
+					}
+					var option10 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option10 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant9 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant9 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant9 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant9 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option10 = witTypes.Some[golem_core_types.NumericBound](variant9)
+					default:
+						panic("unreachable")
+					}
+					var option12 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option12 = witTypes.None[string]()
+					case 1:
+						value11 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option12 = witTypes.Some[string](value11)
+					default:
+						panic("unreachable")
+					}
+
+					option13 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option8, option10, option12})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyS16Type(option13)
+
+			case 4:
+				var option20 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option20 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option15 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option15 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant14 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant14 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant14 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant14 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option15 = witTypes.Some[golem_core_types.NumericBound](variant14)
+					default:
+						panic("unreachable")
+					}
+					var option17 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option17 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant16 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant16 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant16 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant16 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option17 = witTypes.Some[golem_core_types.NumericBound](variant16)
+					default:
+						panic("unreachable")
+					}
+					var option19 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option19 = witTypes.None[string]()
+					case 1:
+						value18 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option19 = witTypes.Some[string](value18)
+					default:
+						panic("unreachable")
+					}
+
+					option20 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option15, option17, option19})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyS32Type(option20)
+
+			case 5:
+				var option27 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option27 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option22 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option22 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant21 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant21 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant21 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant21 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option22 = witTypes.Some[golem_core_types.NumericBound](variant21)
+					default:
+						panic("unreachable")
+					}
+					var option24 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option24 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant23 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant23 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant23 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant23 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option24 = witTypes.Some[golem_core_types.NumericBound](variant23)
+					default:
+						panic("unreachable")
+					}
+					var option26 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option26 = witTypes.None[string]()
+					case 1:
+						value25 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option26 = witTypes.Some[string](value25)
+					default:
+						panic("unreachable")
+					}
+
+					option27 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option22, option24, option26})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyS64Type(option27)
+
+			case 6:
+				var option34 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option34 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option29 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option29 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant28 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant28 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant28 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant28 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option29 = witTypes.Some[golem_core_types.NumericBound](variant28)
+					default:
+						panic("unreachable")
+					}
+					var option31 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option31 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant30 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant30 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant30 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant30 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option31 = witTypes.Some[golem_core_types.NumericBound](variant30)
+					default:
+						panic("unreachable")
+					}
+					var option33 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option33 = witTypes.None[string]()
+					case 1:
+						value32 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option33 = witTypes.Some[string](value32)
+					default:
+						panic("unreachable")
+					}
+
+					option34 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option29, option31, option33})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyU8Type(option34)
+
+			case 7:
+				var option41 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option41 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option36 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option36 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant35 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant35 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant35 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant35 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option36 = witTypes.Some[golem_core_types.NumericBound](variant35)
+					default:
+						panic("unreachable")
+					}
+					var option38 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option38 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant37 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant37 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant37 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant37 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option38 = witTypes.Some[golem_core_types.NumericBound](variant37)
+					default:
+						panic("unreachable")
+					}
+					var option40 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option40 = witTypes.None[string]()
+					case 1:
+						value39 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option40 = witTypes.Some[string](value39)
+					default:
+						panic("unreachable")
+					}
+
+					option41 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option36, option38, option40})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyU16Type(option41)
+
+			case 8:
+				var option48 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option48 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option43 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option43 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant42 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant42 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant42 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant42 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option43 = witTypes.Some[golem_core_types.NumericBound](variant42)
+					default:
+						panic("unreachable")
+					}
+					var option45 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option45 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant44 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant44 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant44 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant44 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option45 = witTypes.Some[golem_core_types.NumericBound](variant44)
+					default:
+						panic("unreachable")
+					}
+					var option47 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option47 = witTypes.None[string]()
+					case 1:
+						value46 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option47 = witTypes.Some[string](value46)
+					default:
+						panic("unreachable")
+					}
+
+					option48 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option43, option45, option47})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyU32Type(option48)
+
+			case 9:
+				var option55 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option55 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option50 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option50 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant49 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant49 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant49 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant49 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option50 = witTypes.Some[golem_core_types.NumericBound](variant49)
+					default:
+						panic("unreachable")
+					}
+					var option52 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option52 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant51 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant51 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant51 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant51 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option52 = witTypes.Some[golem_core_types.NumericBound](variant51)
+					default:
+						panic("unreachable")
+					}
+					var option54 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option54 = witTypes.None[string]()
+					case 1:
+						value53 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option54 = witTypes.Some[string](value53)
+					default:
+						panic("unreachable")
+					}
+
+					option55 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option50, option52, option54})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyU64Type(option55)
+
+			case 10:
+				var option62 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option62 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option57 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option57 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant56 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant56 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant56 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant56 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option57 = witTypes.Some[golem_core_types.NumericBound](variant56)
+					default:
+						panic("unreachable")
+					}
+					var option59 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option59 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant58 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant58 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant58 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant58 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option59 = witTypes.Some[golem_core_types.NumericBound](variant58)
+					default:
+						panic("unreachable")
+					}
+					var option61 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option61 = witTypes.None[string]()
+					case 1:
+						value60 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option61 = witTypes.Some[string](value60)
+					default:
+						panic("unreachable")
+					}
+
+					option62 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option57, option59, option61})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyF32Type(option62)
+
+			case 11:
+				var option69 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option69 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option64 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option64 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant63 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant63 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant63 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant63 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option64 = witTypes.Some[golem_core_types.NumericBound](variant63)
+					default:
+						panic("unreachable")
+					}
+					var option66 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option66 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant65 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant65 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant65 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant65 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option66 = witTypes.Some[golem_core_types.NumericBound](variant65)
+					default:
+						panic("unreachable")
+					}
+					var option68 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option68 = witTypes.None[string]()
+					case 1:
+						value67 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option68 = witTypes.Some[string](value67)
+					default:
+						panic("unreachable")
+					}
+
+					option69 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option64, option66, option68})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyF64Type(option69)
+
+			case 12:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+			case 13:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+			case 14:
+				result81 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+					value70 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var option72 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+					case 0:
+
+						option72 = witTypes.None[string]()
+					case 1:
+						value71 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						option72 = witTypes.Some[string](value71)
+					default:
+						panic("unreachable")
+					}
+					result := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+						value73 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result = append(result, value73)
+					}
+
+					result75 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+						value74 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result75 = append(result75, value74)
+					}
+
+					var option77 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+					case 0:
+
+						option77 = witTypes.None[string]()
+					case 1:
+						value76 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+						option77 = witTypes.Some[string](value76)
+					default:
+						panic("unreachable")
+					}
+					var option80 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+					case 0:
+
+						option80 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant79 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+						case 0:
+
+							variant79 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant79 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant79 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value78 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+							variant79 = golem_core_types.MakeRoleOther(value78)
+
+						default:
+							panic("unreachable")
+						}
+
+						option80 = witTypes.Some[golem_core_types.Role](variant79)
+					default:
+						panic("unreachable")
+					}
+
+					result81 = append(result81, golem_core_types.NamedFieldType{value70, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option72, result, result75, option77, option80}})
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyRecordType(result81)
+
+			case 15:
+				result95 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+					value82 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var option83 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+
+						option83 = witTypes.None[int32]()
+					case 1:
+
+						option83 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+					default:
+						panic("unreachable")
+					}
+					var option85 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						option85 = witTypes.None[string]()
+					case 1:
+						value84 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+						option85 = witTypes.Some[string](value84)
+					default:
+						panic("unreachable")
+					}
+					result87 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+						value86 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result87 = append(result87, value86)
+					}
+
+					result89 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+						value88 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result89 = append(result89, value88)
+					}
+
+					var option91 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+					case 0:
+
+						option91 = witTypes.None[string]()
+					case 1:
+						value90 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+						option91 = witTypes.Some[string](value90)
+					default:
+						panic("unreachable")
+					}
+					var option94 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+					case 0:
+
+						option94 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant93 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+						case 0:
+
+							variant93 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant93 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant93 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value92 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+							variant93 = golem_core_types.MakeRoleOther(value92)
+
+						default:
+							panic("unreachable")
+						}
+
+						option94 = witTypes.Some[golem_core_types.Role](variant93)
+					default:
+						panic("unreachable")
+					}
+
+					result95 = append(result95, golem_core_types.VariantCaseType{value82, option83, golem_core_types.MetadataEnvelope{option85, result87, result89, option91, option94}})
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyVariantType(result95)
+
+			case 16:
+				result97 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+					value96 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result97 = append(result97, value96)
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyEnumType(result97)
+
+			case 17:
+				result99 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+					value98 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result99 = append(result99, value98)
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyFlagsType(result99)
+
+			case 18:
+				result100 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result100 = append(result100, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyTupleType(result100)
+
+			case 19:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 20:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+			case 21:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 22:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 23:
+				var option101 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option101 = witTypes.None[int32]()
+				case 1:
+
+					option101 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+				default:
+					panic("unreachable")
+				}
+				var option102 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+				case 0:
+
+					option102 = witTypes.None[int32]()
+				case 1:
+
+					option102 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option101, option102})
+
+			case 24:
+				var option105 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option105 = witTypes.None[[]string]()
+				case 1:
+					result104 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+						value103 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result104 = append(result104, value103)
+					}
+
+					option105 = witTypes.Some[[]string](result104)
+				default:
+					panic("unreachable")
+				}
+				var option106 witTypes.Option[uint32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+				case 0:
+
+					option106 = witTypes.None[uint32]()
+				case 1:
+
+					option106 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+				default:
+					panic("unreachable")
+				}
+				var option107 witTypes.Option[uint32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+				case 0:
+
+					option107 = witTypes.None[uint32]()
+				case 1:
+
+					option107 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+				default:
+					panic("unreachable")
+				}
+				var option109 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+				case 0:
+
+					option109 = witTypes.None[string]()
+				case 1:
+					value108 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+					option109 = witTypes.Some[string](value108)
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option105, option106, option107, option109})
+
+			case 25:
+				var option112 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option112 = witTypes.None[[]string]()
+				case 1:
+					result111 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+						value110 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result111 = append(result111, value110)
+					}
+
+					option112 = witTypes.Some[[]string](result111)
+				default:
+					panic("unreachable")
+				}
+				var option113 witTypes.Option[uint32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+				case 0:
+
+					option113 = witTypes.None[uint32]()
+				case 1:
+
+					option113 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+				default:
+					panic("unreachable")
+				}
+				var option114 witTypes.Option[uint32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+				case 0:
+
+					option114 = witTypes.None[uint32]()
+				case 1:
+
+					option114 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option112, option113, option114})
+
+			case 26:
+				var option117 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+				case 0:
+
+					option117 = witTypes.None[[]string]()
+				case 1:
+					result116 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+						value115 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result116 = append(result116, value115)
+					}
+
+					option117 = witTypes.Some[[]string](result116)
+				default:
+					panic("unreachable")
+				}
+				var option120 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+				case 0:
+
+					option120 = witTypes.None[[]string]()
+				case 1:
+					result119 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+						value118 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result119 = append(result119, value118)
+					}
+
+					option120 = witTypes.Some[[]string](result119)
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option117, option120})
+
+			case 27:
+				var option123 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option123 = witTypes.None[[]string]()
+				case 1:
+					result122 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+						value121 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result122 = append(result122, value121)
+					}
+
+					option123 = witTypes.Some[[]string](result122)
+				default:
+					panic("unreachable")
+				}
+				var option126 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+				case 0:
+
+					option126 = witTypes.None[[]string]()
+				case 1:
+					result125 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+						value124 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result125 = append(result125, value124)
+					}
+
+					option126 = witTypes.Some[[]string](result125)
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option123, option126})
+
+			case 28:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+			case 29:
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+			case 30:
+				value127 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				result129 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+					value128 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result129 = append(result129, value128)
+				}
+
+				var option131 witTypes.Option[golem_core_types.QuantityValue]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+				case 0:
+
+					option131 = witTypes.None[golem_core_types.QuantityValue]()
+				case 1:
+					value130 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+					option131 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value130})
+				default:
+					panic("unreachable")
+				}
+				var option133 witTypes.Option[golem_core_types.QuantityValue]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+				case 0:
+
+					option133 = witTypes.None[golem_core_types.QuantityValue]()
+				case 1:
+					value132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+					option133 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value132})
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value127, result129, option131, option133})
+
+			case 31:
+				result155 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+					value134 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var variant143 golem_core_types.DiscriminatorRule
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+					case 0:
+						value135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						variant143 = golem_core_types.MakeDiscriminatorRulePrefix(value135)
+
+					case 1:
+						value136 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						variant143 = golem_core_types.MakeDiscriminatorRuleSuffix(value136)
+
+					case 2:
+						value137 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						variant143 = golem_core_types.MakeDiscriminatorRuleContains(value137)
+
+					case 3:
+						value138 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						variant143 = golem_core_types.MakeDiscriminatorRuleRegex(value138)
+
+					case 4:
+						value139 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+						var option141 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+						case 0:
+
+							option141 = witTypes.None[string]()
+						case 1:
+							value140 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+							option141 = witTypes.Some[string](value140)
+						default:
+							panic("unreachable")
+						}
+
+						variant143 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value139, option141})
+
+					case 5:
+						value142 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						variant143 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value142)
+
+					default:
+						panic("unreachable")
+					}
+					var option145 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+					case 0:
+
+						option145 = witTypes.None[string]()
+					case 1:
+						value144 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+						option145 = witTypes.Some[string](value144)
+					default:
+						panic("unreachable")
+					}
+					result147 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+						value146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result147 = append(result147, value146)
+					}
+
+					result149 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+						value148 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result149 = append(result149, value148)
+					}
+
+					var option151 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+					case 0:
+
+						option151 = witTypes.None[string]()
+					case 1:
+						value150 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+						option151 = witTypes.Some[string](value150)
+					default:
+						panic("unreachable")
+					}
+					var option154 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+					case 0:
+
+						option154 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant153 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+						case 0:
+
+							variant153 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant153 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant153 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value152 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+							variant153 = golem_core_types.MakeRoleOther(value152)
+
+						default:
+							panic("unreachable")
+						}
+
+						option154 = witTypes.Some[golem_core_types.Role](variant153)
+					default:
+						panic("unreachable")
+					}
+
+					result155 = append(result155, golem_core_types.UnionBranch{value134, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant143, golem_core_types.MetadataEnvelope{option145, result147, result149, option151, option154}})
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result155})
+
+			case 32:
+				var option157 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+				case 0:
+
+					option157 = witTypes.None[string]()
+				case 1:
+					value156 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+					option157 = witTypes.Some[string](value156)
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option157})
+
+			case 33:
+				var option159 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option159 = witTypes.None[string]()
+				case 1:
+					value158 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+					option159 = witTypes.Some[string](value158)
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option159})
+
+			case 34:
+				var option160 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option160 = witTypes.None[int32]()
+				case 1:
+
+					option160 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyFutureType(option160)
+
+			case 35:
+				var option161 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option161 = witTypes.None[int32]()
+				case 1:
+
+					option161 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+				default:
+					panic("unreachable")
+				}
+
+				variant162 = golem_core_types.MakeSchemaTypeBodyStreamType(option161)
+
+			default:
+				panic("unreachable")
+			}
+			var option164 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+			case 0:
+
+				option164 = witTypes.None[string]()
+			case 1:
+				value163 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+				option164 = witTypes.Some[string](value163)
+			default:
+				panic("unreachable")
+			}
+			result166 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+				value165 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+				result166 = append(result166, value165)
+			}
+
+			result168 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+				value167 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+				result168 = append(result168, value167)
+			}
+
+			var option170 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+			case 0:
+
+				option170 = witTypes.None[string]()
+			case 1:
+				value169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+				option170 = witTypes.Some[string](value169)
+			default:
+				panic("unreachable")
+			}
+			var option173 witTypes.Option[golem_core_types.Role]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+			case 0:
+
+				option173 = witTypes.None[golem_core_types.Role]()
+			case 1:
+				var variant172 golem_core_types.Role
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+				case 0:
+
+					variant172 = golem_core_types.MakeRoleMultimodal()
+
+				case 1:
+
+					variant172 = golem_core_types.MakeRoleUnstructuredText()
+
+				case 2:
+
+					variant172 = golem_core_types.MakeRoleUnstructuredBinary()
+
+				case 3:
+					value171 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+					variant172 = golem_core_types.MakeRoleOther(value171)
+
+				default:
+					panic("unreachable")
+				}
+
+				option173 = witTypes.Some[golem_core_types.Role](variant172)
+			default:
+				panic("unreachable")
+			}
+
+			result174 = append(result174, golem_core_types.SchemaTypeNode{variant162, golem_core_types.MetadataEnvelope{option164, result166, result168, option170, option173}})
+		}
+
+		result178 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 9*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 9*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 8*4))))), index*(6*4))
+			value175 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			var option177 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+			case 0:
+
+				option177 = witTypes.None[string]()
+			case 1:
+				value176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+				option177 = witTypes.Some[string](value176)
+			default:
+				panic("unreachable")
+			}
+
+			result178 = append(result178, golem_core_types.SchemaTypeDef{value175, option177, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+		}
+
+		var option180 witTypes.Option[string]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 11*4)))) {
+		case 0:
+
+			option180 = witTypes.None[string]()
+		case 1:
+			value179 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 12*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 13*4))))
+
+			option180 = witTypes.Some[string](value179)
+		default:
+			panic("unreachable")
+		}
+		value181 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 15*4))))
+		var option183 witTypes.Option[string]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 16*4)))) {
+		case 0:
+
+			option183 = witTypes.None[string]()
+		case 1:
+			value182 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 17*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 18*4))))
+
+			option183 = witTypes.Some[string](value182)
+		default:
+			panic("unreachable")
+		}
+		var variant198 golem_agent_common.InputSchema
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 19*4)))) {
+		case 0:
+			result197 := make([]golem_agent_common.NamedField, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 21*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 21*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 20*4))))), index*(8+16*4))
+				value184 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+				var variant185 golem_agent_common.FieldSource
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+				case 0:
+
+					variant185 = golem_agent_common.MakeFieldSourceUserSupplied()
+
+				case 1:
+
+					variant185 = golem_agent_common.MakeFieldSourceAutoInjected(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))))))
+
+				default:
+					panic("unreachable")
+				}
+				var option187 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+
+					option187 = witTypes.None[string]()
+				case 1:
+					value186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+					option187 = witTypes.Some[string](value186)
+				default:
+					panic("unreachable")
+				}
+				result189 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+					value188 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result189 = append(result189, value188)
+				}
+
+				result191 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+					value190 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result191 = append(result191, value190)
+				}
+
+				var option193 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+				case 0:
+
+					option193 = witTypes.None[string]()
+				case 1:
+					value192 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+					option193 = witTypes.Some[string](value192)
+				default:
+					panic("unreachable")
+				}
+				var option196 witTypes.Option[golem_core_types.Role]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+				case 0:
+
+					option196 = witTypes.None[golem_core_types.Role]()
+				case 1:
+					var variant195 golem_core_types.Role
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+					case 0:
+
+						variant195 = golem_core_types.MakeRoleMultimodal()
+
+					case 1:
+
+						variant195 = golem_core_types.MakeRoleUnstructuredText()
+
+					case 2:
+
+						variant195 = golem_core_types.MakeRoleUnstructuredBinary()
+
+					case 3:
+						value194 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+						variant195 = golem_core_types.MakeRoleOther(value194)
+
+					default:
+						panic("unreachable")
+					}
+
+					option196 = witTypes.Some[golem_core_types.Role](variant195)
+				default:
+					panic("unreachable")
+				}
+
+				result197 = append(result197, golem_agent_common.NamedField{value184, variant185, *(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))), golem_core_types.MetadataEnvelope{option187, result189, result191, option193, option196}})
+			}
+
+			variant198 = golem_agent_common.MakeInputSchemaParameters(result197)
+
+		default:
+			panic("unreachable")
+		}
+		result238 := make([]golem_agent_common.AgentMethod, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 23*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 23*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 22*4))))), index*(40+12*4))
+			value199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			value200 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+			result217 := make([]golem_agent_common.HttpEndpointDetails, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))), index*(12*4))
+				var variant202 golem_agent_common.HttpMethod
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant202 = golem_agent_common.MakeHttpMethodGet()
+
+				case 1:
+
+					variant202 = golem_agent_common.MakeHttpMethodHead()
+
+				case 2:
+
+					variant202 = golem_agent_common.MakeHttpMethodPost()
+
+				case 3:
+
+					variant202 = golem_agent_common.MakeHttpMethodPut()
+
+				case 4:
+
+					variant202 = golem_agent_common.MakeHttpMethodDelete()
+
+				case 5:
+
+					variant202 = golem_agent_common.MakeHttpMethodConnect()
+
+				case 6:
+
+					variant202 = golem_agent_common.MakeHttpMethodOptions()
+
+				case 7:
+
+					variant202 = golem_agent_common.MakeHttpMethodTrace()
+
+				case 8:
+
+					variant202 = golem_agent_common.MakeHttpMethodPatch()
+
+				case 9:
+					value201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+					variant202 = golem_agent_common.MakeHttpMethodCustom(value201)
+
+				default:
+					panic("unreachable")
+				}
+				result207 := make([]golem_agent_common.PathSegment, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))), index*(3*4))
+					var variant206 golem_agent_common.PathSegment
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+						value203 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+						variant206 = golem_agent_common.MakePathSegmentLiteral(value203)
+
+					case 1:
+
+						variant206 = golem_agent_common.MakePathSegmentSystemVariable(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))))
+
+					case 2:
+						value204 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+						variant206 = golem_agent_common.MakePathSegmentPathVariable(golem_agent_common.PathVariable{value204})
+
+					case 3:
+						value205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+						variant206 = golem_agent_common.MakePathSegmentRemainingPathVariable(golem_agent_common.PathVariable{value205})
+
+					default:
+						panic("unreachable")
+					}
+
+					result207 = append(result207, variant206)
+				}
+
+				result210 := make([]golem_agent_common.HeaderVariable, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))), index*(4*4))
+					value208 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result210 = append(result210, golem_agent_common.HeaderVariable{value208, value209})
+				}
+
+				result213 := make([]golem_agent_common.QueryVariable, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))), index*(4*4))
+					value211 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value212 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result213 = append(result213, golem_agent_common.QueryVariable{value211, value212})
+				}
+
+				var option214 witTypes.Option[golem_agent_common.AuthDetails]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+				case 0:
+
+					option214 = witTypes.None[golem_agent_common.AuthDetails]()
+				case 1:
+
+					option214 = witTypes.Some[golem_agent_common.AuthDetails](golem_agent_common.AuthDetails{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (1 + 9*4)))) != 0)})
+				default:
+					panic("unreachable")
+				}
+				result216 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))))), index*(2*4))
+					value215 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result216 = append(result216, value215)
+				}
+
+				result217 = append(result217, golem_agent_common.HttpEndpointDetails{variant202, result207, result210, result213, option214, golem_agent_common.CorsOptions{result216}})
+			}
+
+			var option219 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+			case 0:
+
+				option219 = witTypes.None[string]()
+			case 1:
+				value218 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+				option219 = witTypes.Some[string](value218)
+			default:
+				panic("unreachable")
+			}
+			var variant234 golem_agent_common.InputSchema
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+			case 0:
+				result233 := make([]golem_agent_common.NamedField, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))))), index*(8+16*4))
+					value220 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var variant221 golem_agent_common.FieldSource
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+
+						variant221 = golem_agent_common.MakeFieldSourceUserSupplied()
+
+					case 1:
+
+						variant221 = golem_agent_common.MakeFieldSourceAutoInjected(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))))))
+
+					default:
+						panic("unreachable")
+					}
+					var option223 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						option223 = witTypes.None[string]()
+					case 1:
+						value222 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+						option223 = witTypes.Some[string](value222)
+					default:
+						panic("unreachable")
+					}
+					result225 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+						value224 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result225 = append(result225, value224)
+					}
+
+					result227 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+						value226 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result227 = append(result227, value226)
+					}
+
+					var option229 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+					case 0:
+
+						option229 = witTypes.None[string]()
+					case 1:
+						value228 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+						option229 = witTypes.Some[string](value228)
+					default:
+						panic("unreachable")
+					}
+					var option232 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+					case 0:
+
+						option232 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant231 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+						case 0:
+
+							variant231 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant231 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant231 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value230 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+							variant231 = golem_core_types.MakeRoleOther(value230)
+
+						default:
+							panic("unreachable")
+						}
+
+						option232 = witTypes.Some[golem_core_types.Role](variant231)
+					default:
+						panic("unreachable")
+					}
+
+					result233 = append(result233, golem_agent_common.NamedField{value220, variant221, *(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))), golem_core_types.MetadataEnvelope{option223, result225, result227, option229, option232}})
+				}
+
+				variant234 = golem_agent_common.MakeInputSchemaParameters(result233)
+
+			default:
+				panic("unreachable")
+			}
+			var variant235 golem_agent_common.OutputSchema
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) {
+			case 0:
+
+				variant235 = golem_agent_common.MakeOutputSchemaUnit()
+
+			case 1:
+
+				variant235 = golem_agent_common.MakeOutputSchemaSingle(*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 12*4))))
+
+			default:
+				panic("unreachable")
+			}
+			var option237 witTypes.Option[golem_agent_common.ReadOnlyConfig]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+			case 0:
+
+				option237 = witTypes.None[golem_agent_common.ReadOnlyConfig]()
+			case 1:
+				var variant236 golem_agent_common.CachePolicy
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4)))) {
+				case 0:
+
+					variant236 = golem_agent_common.MakeCachePolicyNoCache()
+
+				case 1:
+
+					variant236 = golem_agent_common.MakeCachePolicyUntilWrite()
+
+				case 2:
+
+					variant236 = golem_agent_common.MakeCachePolicyTtl(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 12*4)))))
+
+				default:
+					panic("unreachable")
+				}
+
+				option237 = witTypes.Some[golem_agent_common.ReadOnlyConfig](golem_agent_common.ReadOnlyConfig{variant236, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4)))) != 0)})
+			default:
+				panic("unreachable")
+			}
+
+			result238 = append(result238, golem_agent_common.AgentMethod{value199, value200, result217, option219, variant234, variant235, option237})
+		}
+
+		result482 := make([]golem_agent_common.AgentDependency, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 25*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 25*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 24*4))))), index*(23*4))
+			value239 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			var option241 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+			case 0:
+
+				option241 = witTypes.None[string]()
+			case 1:
+				value240 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+				option241 = witTypes.Some[string](value240)
+			default:
+				panic("unreachable")
+			}
+			result417 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))), index*(56+22*4))
+				var variant405 golem_core_types.SchemaTypeBody
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 1:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+				case 2:
+					var option248 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option248 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option243 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option243 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant242 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant242 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant242 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant242 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option243 = witTypes.Some[golem_core_types.NumericBound](variant242)
+						default:
+							panic("unreachable")
+						}
+						var option245 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option245 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant244 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant244 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant244 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant244 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option245 = witTypes.Some[golem_core_types.NumericBound](variant244)
+						default:
+							panic("unreachable")
+						}
+						var option247 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option247 = witTypes.None[string]()
+						case 1:
+							value246 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option247 = witTypes.Some[string](value246)
+						default:
+							panic("unreachable")
+						}
+
+						option248 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option243, option245, option247})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyS8Type(option248)
+
+				case 3:
+					var option255 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option255 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option250 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option250 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant249 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant249 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant249 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant249 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option250 = witTypes.Some[golem_core_types.NumericBound](variant249)
+						default:
+							panic("unreachable")
+						}
+						var option252 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option252 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant251 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant251 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant251 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant251 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option252 = witTypes.Some[golem_core_types.NumericBound](variant251)
+						default:
+							panic("unreachable")
+						}
+						var option254 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option254 = witTypes.None[string]()
+						case 1:
+							value253 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option254 = witTypes.Some[string](value253)
+						default:
+							panic("unreachable")
+						}
+
+						option255 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option250, option252, option254})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyS16Type(option255)
+
+				case 4:
+					var option262 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option262 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option257 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option257 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant256 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant256 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant256 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant256 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option257 = witTypes.Some[golem_core_types.NumericBound](variant256)
+						default:
+							panic("unreachable")
+						}
+						var option259 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option259 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant258 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant258 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant258 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant258 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option259 = witTypes.Some[golem_core_types.NumericBound](variant258)
+						default:
+							panic("unreachable")
+						}
+						var option261 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option261 = witTypes.None[string]()
+						case 1:
+							value260 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option261 = witTypes.Some[string](value260)
+						default:
+							panic("unreachable")
+						}
+
+						option262 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option257, option259, option261})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyS32Type(option262)
+
+				case 5:
+					var option269 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option269 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option264 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option264 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant263 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant263 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant263 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant263 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option264 = witTypes.Some[golem_core_types.NumericBound](variant263)
+						default:
+							panic("unreachable")
+						}
+						var option266 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option266 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant265 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant265 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant265 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant265 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option266 = witTypes.Some[golem_core_types.NumericBound](variant265)
+						default:
+							panic("unreachable")
+						}
+						var option268 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option268 = witTypes.None[string]()
+						case 1:
+							value267 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option268 = witTypes.Some[string](value267)
+						default:
+							panic("unreachable")
+						}
+
+						option269 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option264, option266, option268})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyS64Type(option269)
+
+				case 6:
+					var option276 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option276 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option271 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option271 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant270 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant270 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant270 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant270 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option271 = witTypes.Some[golem_core_types.NumericBound](variant270)
+						default:
+							panic("unreachable")
+						}
+						var option273 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option273 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant272 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant272 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant272 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant272 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option273 = witTypes.Some[golem_core_types.NumericBound](variant272)
+						default:
+							panic("unreachable")
+						}
+						var option275 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option275 = witTypes.None[string]()
+						case 1:
+							value274 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option275 = witTypes.Some[string](value274)
+						default:
+							panic("unreachable")
+						}
+
+						option276 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option271, option273, option275})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyU8Type(option276)
+
+				case 7:
+					var option283 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option283 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option278 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option278 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant277 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant277 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant277 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant277 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option278 = witTypes.Some[golem_core_types.NumericBound](variant277)
+						default:
+							panic("unreachable")
+						}
+						var option280 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option280 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant279 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant279 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant279 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant279 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option280 = witTypes.Some[golem_core_types.NumericBound](variant279)
+						default:
+							panic("unreachable")
+						}
+						var option282 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option282 = witTypes.None[string]()
+						case 1:
+							value281 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option282 = witTypes.Some[string](value281)
+						default:
+							panic("unreachable")
+						}
+
+						option283 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option278, option280, option282})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyU16Type(option283)
+
+				case 8:
+					var option290 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option290 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option285 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option285 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant284 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant284 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant284 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant284 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option285 = witTypes.Some[golem_core_types.NumericBound](variant284)
+						default:
+							panic("unreachable")
+						}
+						var option287 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option287 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant286 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant286 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant286 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant286 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option287 = witTypes.Some[golem_core_types.NumericBound](variant286)
+						default:
+							panic("unreachable")
+						}
+						var option289 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option289 = witTypes.None[string]()
+						case 1:
+							value288 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option289 = witTypes.Some[string](value288)
+						default:
+							panic("unreachable")
+						}
+
+						option290 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option285, option287, option289})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyU32Type(option290)
+
+				case 9:
+					var option297 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option297 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option292 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option292 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant291 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant291 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant291 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant291 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option292 = witTypes.Some[golem_core_types.NumericBound](variant291)
+						default:
+							panic("unreachable")
+						}
+						var option294 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option294 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant293 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant293 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant293 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant293 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option294 = witTypes.Some[golem_core_types.NumericBound](variant293)
+						default:
+							panic("unreachable")
+						}
+						var option296 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option296 = witTypes.None[string]()
+						case 1:
+							value295 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option296 = witTypes.Some[string](value295)
+						default:
+							panic("unreachable")
+						}
+
+						option297 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option292, option294, option296})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyU64Type(option297)
+
+				case 10:
+					var option304 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option304 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option299 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option299 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant298 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant298 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant298 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant298 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option299 = witTypes.Some[golem_core_types.NumericBound](variant298)
+						default:
+							panic("unreachable")
+						}
+						var option301 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option301 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant300 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant300 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant300 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant300 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option301 = witTypes.Some[golem_core_types.NumericBound](variant300)
+						default:
+							panic("unreachable")
+						}
+						var option303 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option303 = witTypes.None[string]()
+						case 1:
+							value302 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option303 = witTypes.Some[string](value302)
+						default:
+							panic("unreachable")
+						}
+
+						option304 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option299, option301, option303})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyF32Type(option304)
+
+				case 11:
+					var option311 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option311 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option306 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option306 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant305 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant305 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant305 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant305 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option306 = witTypes.Some[golem_core_types.NumericBound](variant305)
+						default:
+							panic("unreachable")
+						}
+						var option308 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option308 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant307 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant307 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant307 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant307 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option308 = witTypes.Some[golem_core_types.NumericBound](variant307)
+						default:
+							panic("unreachable")
+						}
+						var option310 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option310 = witTypes.None[string]()
+						case 1:
+							value309 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option310 = witTypes.Some[string](value309)
+						default:
+							panic("unreachable")
+						}
+
+						option311 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option306, option308, option310})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyF64Type(option311)
+
+				case 12:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+				case 13:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+				case 14:
+					result324 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+						value312 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option314 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+						case 0:
+
+							option314 = witTypes.None[string]()
+						case 1:
+							value313 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							option314 = witTypes.Some[string](value313)
+						default:
+							panic("unreachable")
+						}
+						result316 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+							value315 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result316 = append(result316, value315)
+						}
+
+						result318 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+							value317 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result318 = append(result318, value317)
+						}
+
+						var option320 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+						case 0:
+
+							option320 = witTypes.None[string]()
+						case 1:
+							value319 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+							option320 = witTypes.Some[string](value319)
+						default:
+							panic("unreachable")
+						}
+						var option323 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+						case 0:
+
+							option323 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant322 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+							case 0:
+
+								variant322 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant322 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant322 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value321 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+								variant322 = golem_core_types.MakeRoleOther(value321)
+
+							default:
+								panic("unreachable")
+							}
+
+							option323 = witTypes.Some[golem_core_types.Role](variant322)
+						default:
+							panic("unreachable")
+						}
+
+						result324 = append(result324, golem_core_types.NamedFieldType{value312, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option314, result316, result318, option320, option323}})
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyRecordType(result324)
+
+				case 15:
+					result338 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+						value325 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option326 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option326 = witTypes.None[int32]()
+						case 1:
+
+							option326 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+						default:
+							panic("unreachable")
+						}
+						var option328 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option328 = witTypes.None[string]()
+						case 1:
+							value327 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option328 = witTypes.Some[string](value327)
+						default:
+							panic("unreachable")
+						}
+						result330 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+							value329 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result330 = append(result330, value329)
+						}
+
+						result332 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+							value331 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result332 = append(result332, value331)
+						}
+
+						var option334 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+						case 0:
+
+							option334 = witTypes.None[string]()
+						case 1:
+							value333 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+							option334 = witTypes.Some[string](value333)
+						default:
+							panic("unreachable")
+						}
+						var option337 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+						case 0:
+
+							option337 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant336 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+							case 0:
+
+								variant336 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant336 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant336 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value335 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+								variant336 = golem_core_types.MakeRoleOther(value335)
+
+							default:
+								panic("unreachable")
+							}
+
+							option337 = witTypes.Some[golem_core_types.Role](variant336)
+						default:
+							panic("unreachable")
+						}
+
+						result338 = append(result338, golem_core_types.VariantCaseType{value325, option326, golem_core_types.MetadataEnvelope{option328, result330, result332, option334, option337}})
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyVariantType(result338)
+
+				case 16:
+					result340 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+						value339 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result340 = append(result340, value339)
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyEnumType(result340)
+
+				case 17:
+					result342 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+						value341 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result342 = append(result342, value341)
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyFlagsType(result342)
+
+				case 18:
+					result343 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result343 = append(result343, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyTupleType(result343)
+
+				case 19:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 20:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+				case 21:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+				case 22:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 23:
+					var option344 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option344 = witTypes.None[int32]()
+					case 1:
+
+						option344 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+					var option345 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option345 = witTypes.None[int32]()
+					case 1:
+
+						option345 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option344, option345})
+
+				case 24:
+					var option348 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option348 = witTypes.None[[]string]()
+					case 1:
+						result347 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+							value346 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result347 = append(result347, value346)
+						}
+
+						option348 = witTypes.Some[[]string](result347)
+					default:
+						panic("unreachable")
+					}
+					var option349 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+					case 0:
+
+						option349 = witTypes.None[uint32]()
+					case 1:
+
+						option349 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+					var option350 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+					case 0:
+
+						option350 = witTypes.None[uint32]()
+					case 1:
+
+						option350 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+					var option352 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+					case 0:
+
+						option352 = witTypes.None[string]()
+					case 1:
+						value351 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+						option352 = witTypes.Some[string](value351)
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option348, option349, option350, option352})
+
+				case 25:
+					var option355 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option355 = witTypes.None[[]string]()
+					case 1:
+						result354 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+							value353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result354 = append(result354, value353)
+						}
+
+						option355 = witTypes.Some[[]string](result354)
+					default:
+						panic("unreachable")
+					}
+					var option356 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+					case 0:
+
+						option356 = witTypes.None[uint32]()
+					case 1:
+
+						option356 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+					var option357 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+					case 0:
+
+						option357 = witTypes.None[uint32]()
+					case 1:
+
+						option357 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option355, option356, option357})
+
+				case 26:
+					var option360 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+					case 0:
+
+						option360 = witTypes.None[[]string]()
+					case 1:
+						result359 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+							value358 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result359 = append(result359, value358)
+						}
+
+						option360 = witTypes.Some[[]string](result359)
+					default:
+						panic("unreachable")
+					}
+					var option363 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+					case 0:
+
+						option363 = witTypes.None[[]string]()
+					case 1:
+						result362 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+							value361 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result362 = append(result362, value361)
+						}
+
+						option363 = witTypes.Some[[]string](result362)
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option360, option363})
+
+				case 27:
+					var option366 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option366 = witTypes.None[[]string]()
+					case 1:
+						result365 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+							value364 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result365 = append(result365, value364)
+						}
+
+						option366 = witTypes.Some[[]string](result365)
+					default:
+						panic("unreachable")
+					}
+					var option369 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+					case 0:
+
+						option369 = witTypes.None[[]string]()
+					case 1:
+						result368 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+							value367 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result368 = append(result368, value367)
+						}
+
+						option369 = witTypes.Some[[]string](result368)
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option366, option369})
+
+				case 28:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+				case 29:
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+				case 30:
+					value370 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					result372 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+						value371 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result372 = append(result372, value371)
+					}
+
+					var option374 witTypes.Option[golem_core_types.QuantityValue]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+					case 0:
+
+						option374 = witTypes.None[golem_core_types.QuantityValue]()
+					case 1:
+						value373 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+						option374 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value373})
+					default:
+						panic("unreachable")
+					}
+					var option376 witTypes.Option[golem_core_types.QuantityValue]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+					case 0:
+
+						option376 = witTypes.None[golem_core_types.QuantityValue]()
+					case 1:
+						value375 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+						option376 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value375})
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value370, result372, option374, option376})
+
+				case 31:
+					result398 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+						value377 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var variant386 golem_core_types.DiscriminatorRule
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+						case 0:
+							value378 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant386 = golem_core_types.MakeDiscriminatorRulePrefix(value378)
+
+						case 1:
+							value379 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant386 = golem_core_types.MakeDiscriminatorRuleSuffix(value379)
+
+						case 2:
+							value380 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant386 = golem_core_types.MakeDiscriminatorRuleContains(value380)
+
+						case 3:
+							value381 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant386 = golem_core_types.MakeDiscriminatorRuleRegex(value381)
+
+						case 4:
+							value382 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+							var option384 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+							case 0:
+
+								option384 = witTypes.None[string]()
+							case 1:
+								value383 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+								option384 = witTypes.Some[string](value383)
+							default:
+								panic("unreachable")
+							}
+
+							variant386 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value382, option384})
+
+						case 5:
+							value385 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant386 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value385)
+
+						default:
+							panic("unreachable")
+						}
+						var option388 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+						case 0:
+
+							option388 = witTypes.None[string]()
+						case 1:
+							value387 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+							option388 = witTypes.Some[string](value387)
+						default:
+							panic("unreachable")
+						}
+						result390 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+							value389 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result390 = append(result390, value389)
+						}
+
+						result392 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+							value391 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result392 = append(result392, value391)
+						}
+
+						var option394 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+						case 0:
+
+							option394 = witTypes.None[string]()
+						case 1:
+							value393 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+							option394 = witTypes.Some[string](value393)
+						default:
+							panic("unreachable")
+						}
+						var option397 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+						case 0:
+
+							option397 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant396 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+							case 0:
+
+								variant396 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant396 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant396 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value395 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+								variant396 = golem_core_types.MakeRoleOther(value395)
+
+							default:
+								panic("unreachable")
+							}
+
+							option397 = witTypes.Some[golem_core_types.Role](variant396)
+						default:
+							panic("unreachable")
+						}
+
+						result398 = append(result398, golem_core_types.UnionBranch{value377, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant386, golem_core_types.MetadataEnvelope{option388, result390, result392, option394, option397}})
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result398})
+
+				case 32:
+					var option400 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+					case 0:
+
+						option400 = witTypes.None[string]()
+					case 1:
+						value399 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						option400 = witTypes.Some[string](value399)
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option400})
+
+				case 33:
+					var option402 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option402 = witTypes.None[string]()
+					case 1:
+						value401 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+						option402 = witTypes.Some[string](value401)
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option402})
+
+				case 34:
+					var option403 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option403 = witTypes.None[int32]()
+					case 1:
+
+						option403 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyFutureType(option403)
+
+				case 35:
+					var option404 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option404 = witTypes.None[int32]()
+					case 1:
+
+						option404 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+
+					variant405 = golem_core_types.MakeSchemaTypeBodyStreamType(option404)
+
+				default:
+					panic("unreachable")
+				}
+				var option407 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+				case 0:
+
+					option407 = witTypes.None[string]()
+				case 1:
+					value406 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+					option407 = witTypes.Some[string](value406)
+				default:
+					panic("unreachable")
+				}
+				result409 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+					value408 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result409 = append(result409, value408)
+				}
+
+				result411 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+					value410 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result411 = append(result411, value410)
+				}
+
+				var option413 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+				case 0:
+
+					option413 = witTypes.None[string]()
+				case 1:
+					value412 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+					option413 = witTypes.Some[string](value412)
+				default:
+					panic("unreachable")
+				}
+				var option416 witTypes.Option[golem_core_types.Role]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+				case 0:
+
+					option416 = witTypes.None[golem_core_types.Role]()
+				case 1:
+					var variant415 golem_core_types.Role
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+					case 0:
+
+						variant415 = golem_core_types.MakeRoleMultimodal()
+
+					case 1:
+
+						variant415 = golem_core_types.MakeRoleUnstructuredText()
+
+					case 2:
+
+						variant415 = golem_core_types.MakeRoleUnstructuredBinary()
+
+					case 3:
+						value414 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+						variant415 = golem_core_types.MakeRoleOther(value414)
+
+					default:
+						panic("unreachable")
+					}
+
+					option416 = witTypes.Some[golem_core_types.Role](variant415)
+				default:
+					panic("unreachable")
+				}
+
+				result417 = append(result417, golem_core_types.SchemaTypeNode{variant405, golem_core_types.MetadataEnvelope{option407, result409, result411, option413, option416}})
+			}
+
+			result421 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))), index*(6*4))
+				value418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+				var option420 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+				case 0:
+
+					option420 = witTypes.None[string]()
+				case 1:
+					value419 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+					option420 = witTypes.Some[string](value419)
+				default:
+					panic("unreachable")
+				}
+
+				result421 = append(result421, golem_core_types.SchemaTypeDef{value418, option420, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+			}
+
+			var option423 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+			case 0:
+
+				option423 = witTypes.None[string]()
+			case 1:
+				value422 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+				option423 = witTypes.Some[string](value422)
+			default:
+				panic("unreachable")
+			}
+			value424 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))
+			var option426 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))) {
+			case 0:
+
+				option426 = witTypes.None[string]()
+			case 1:
+				value425 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))))
+
+				option426 = witTypes.Some[string](value425)
+			default:
+				panic("unreachable")
+			}
+			var variant441 golem_agent_common.InputSchema
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) {
+			case 0:
+				result440 := make([]golem_agent_common.NamedField, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4))))), index*(8+16*4))
+					value427 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var variant428 golem_agent_common.FieldSource
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+
+						variant428 = golem_agent_common.MakeFieldSourceUserSupplied()
+
+					case 1:
+
+						variant428 = golem_agent_common.MakeFieldSourceAutoInjected(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))))))
+
+					default:
+						panic("unreachable")
+					}
+					var option430 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						option430 = witTypes.None[string]()
+					case 1:
+						value429 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+						option430 = witTypes.Some[string](value429)
+					default:
+						panic("unreachable")
+					}
+					result432 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+						value431 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result432 = append(result432, value431)
+					}
+
+					result434 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+						value433 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result434 = append(result434, value433)
+					}
+
+					var option436 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+					case 0:
+
+						option436 = witTypes.None[string]()
+					case 1:
+						value435 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+						option436 = witTypes.Some[string](value435)
+					default:
+						panic("unreachable")
+					}
+					var option439 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+					case 0:
+
+						option439 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant438 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+						case 0:
+
+							variant438 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant438 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant438 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value437 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+							variant438 = golem_core_types.MakeRoleOther(value437)
+
+						default:
+							panic("unreachable")
+						}
+
+						option439 = witTypes.Some[golem_core_types.Role](variant438)
+					default:
+						panic("unreachable")
+					}
+
+					result440 = append(result440, golem_agent_common.NamedField{value427, variant428, *(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))), golem_core_types.MetadataEnvelope{option430, result432, result434, option436, option439}})
+				}
+
+				variant441 = golem_agent_common.MakeInputSchemaParameters(result440)
+
+			default:
+				panic("unreachable")
+			}
+			result481 := make([]golem_agent_common.AgentMethod, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))))), index*(40+12*4))
+				value442 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+				value443 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+				result460 := make([]golem_agent_common.HttpEndpointDetails, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))), index*(12*4))
+					var variant445 golem_agent_common.HttpMethod
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant445 = golem_agent_common.MakeHttpMethodGet()
+
+					case 1:
+
+						variant445 = golem_agent_common.MakeHttpMethodHead()
+
+					case 2:
+
+						variant445 = golem_agent_common.MakeHttpMethodPost()
+
+					case 3:
+
+						variant445 = golem_agent_common.MakeHttpMethodPut()
+
+					case 4:
+
+						variant445 = golem_agent_common.MakeHttpMethodDelete()
+
+					case 5:
+
+						variant445 = golem_agent_common.MakeHttpMethodConnect()
+
+					case 6:
+
+						variant445 = golem_agent_common.MakeHttpMethodOptions()
+
+					case 7:
+
+						variant445 = golem_agent_common.MakeHttpMethodTrace()
+
+					case 8:
+
+						variant445 = golem_agent_common.MakeHttpMethodPatch()
+
+					case 9:
+						value444 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+						variant445 = golem_agent_common.MakeHttpMethodCustom(value444)
+
+					default:
+						panic("unreachable")
+					}
+					result450 := make([]golem_agent_common.PathSegment, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))), index*(3*4))
+						var variant449 golem_agent_common.PathSegment
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+							value446 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+							variant449 = golem_agent_common.MakePathSegmentLiteral(value446)
+
+						case 1:
+
+							variant449 = golem_agent_common.MakePathSegmentSystemVariable(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))))
+
+						case 2:
+							value447 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+							variant449 = golem_agent_common.MakePathSegmentPathVariable(golem_agent_common.PathVariable{value447})
+
+						case 3:
+							value448 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+							variant449 = golem_agent_common.MakePathSegmentRemainingPathVariable(golem_agent_common.PathVariable{value448})
+
+						default:
+							panic("unreachable")
+						}
+
+						result450 = append(result450, variant449)
+					}
+
+					result453 := make([]golem_agent_common.HeaderVariable, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))), index*(4*4))
+						value451 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						value452 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+						result453 = append(result453, golem_agent_common.HeaderVariable{value451, value452})
+					}
+
+					result456 := make([]golem_agent_common.QueryVariable, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))), index*(4*4))
+						value454 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						value455 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+						result456 = append(result456, golem_agent_common.QueryVariable{value454, value455})
+					}
+
+					var option457 witTypes.Option[golem_agent_common.AuthDetails]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+					case 0:
+
+						option457 = witTypes.None[golem_agent_common.AuthDetails]()
+					case 1:
+
+						option457 = witTypes.Some[golem_agent_common.AuthDetails](golem_agent_common.AuthDetails{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (1 + 9*4)))) != 0)})
+					default:
+						panic("unreachable")
+					}
+					result459 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))))), index*(2*4))
+						value458 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result459 = append(result459, value458)
+					}
+
+					result460 = append(result460, golem_agent_common.HttpEndpointDetails{variant445, result450, result453, result456, option457, golem_agent_common.CorsOptions{result459}})
+				}
+
+				var option462 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+				case 0:
+
+					option462 = witTypes.None[string]()
+				case 1:
+					value461 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+					option462 = witTypes.Some[string](value461)
+				default:
+					panic("unreachable")
+				}
+				var variant477 golem_agent_common.InputSchema
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+				case 0:
+					result476 := make([]golem_agent_common.NamedField, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))))), index*(8+16*4))
+						value463 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var variant464 golem_agent_common.FieldSource
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							variant464 = golem_agent_common.MakeFieldSourceUserSupplied()
+
+						case 1:
+
+							variant464 = golem_agent_common.MakeFieldSourceAutoInjected(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))))))
+
+						default:
+							panic("unreachable")
+						}
+						var option466 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option466 = witTypes.None[string]()
+						case 1:
+							value465 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option466 = witTypes.Some[string](value465)
+						default:
+							panic("unreachable")
+						}
+						result468 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+							value467 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result468 = append(result468, value467)
+						}
+
+						result470 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+							value469 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result470 = append(result470, value469)
+						}
+
+						var option472 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+						case 0:
+
+							option472 = witTypes.None[string]()
+						case 1:
+							value471 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+							option472 = witTypes.Some[string](value471)
+						default:
+							panic("unreachable")
+						}
+						var option475 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+						case 0:
+
+							option475 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant474 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+							case 0:
+
+								variant474 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant474 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant474 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value473 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+								variant474 = golem_core_types.MakeRoleOther(value473)
+
+							default:
+								panic("unreachable")
+							}
+
+							option475 = witTypes.Some[golem_core_types.Role](variant474)
+						default:
+							panic("unreachable")
+						}
+
+						result476 = append(result476, golem_agent_common.NamedField{value463, variant464, *(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))), golem_core_types.MetadataEnvelope{option466, result468, result470, option472, option475}})
+					}
+
+					variant477 = golem_agent_common.MakeInputSchemaParameters(result476)
+
+				default:
+					panic("unreachable")
+				}
+				var variant478 golem_agent_common.OutputSchema
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) {
+				case 0:
+
+					variant478 = golem_agent_common.MakeOutputSchemaUnit()
+
+				case 1:
+
+					variant478 = golem_agent_common.MakeOutputSchemaSingle(*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 12*4))))
+
+				default:
+					panic("unreachable")
+				}
+				var option480 witTypes.Option[golem_agent_common.ReadOnlyConfig]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+				case 0:
+
+					option480 = witTypes.None[golem_agent_common.ReadOnlyConfig]()
+				case 1:
+					var variant479 golem_agent_common.CachePolicy
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4)))) {
+					case 0:
+
+						variant479 = golem_agent_common.MakeCachePolicyNoCache()
+
+					case 1:
+
+						variant479 = golem_agent_common.MakeCachePolicyUntilWrite()
+
+					case 2:
+
+						variant479 = golem_agent_common.MakeCachePolicyTtl(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 12*4)))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option480 = witTypes.Some[golem_agent_common.ReadOnlyConfig](golem_agent_common.ReadOnlyConfig{variant479, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4)))) != 0)})
+				default:
+					panic("unreachable")
+				}
+
+				result481 = append(result481, golem_agent_common.AgentMethod{value442, value443, result460, option462, variant477, variant478, option480})
+			}
+
+			result482 = append(result482, golem_agent_common.AgentDependency{value239, option241, golem_core_types.SchemaGraph{result417, result421, *(*int32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))}, golem_agent_common.AgentConstructor{option423, value424, option426, variant441}, result481})
+		}
+
+		var option496 witTypes.Option[golem_agent_common.HttpMountDetails]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 27*4)))) {
+		case 0:
+
+			option496 = witTypes.None[golem_agent_common.HttpMountDetails]()
+		case 1:
+			result487 := make([]golem_agent_common.PathSegment, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 29*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 29*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 28*4))))), index*(3*4))
+				var variant486 golem_agent_common.PathSegment
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+					value483 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+					variant486 = golem_agent_common.MakePathSegmentLiteral(value483)
+
+				case 1:
+
+					variant486 = golem_agent_common.MakePathSegmentSystemVariable(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))))
+
+				case 2:
+					value484 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+					variant486 = golem_agent_common.MakePathSegmentPathVariable(golem_agent_common.PathVariable{value484})
+
+				case 3:
+					value485 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+					variant486 = golem_agent_common.MakePathSegmentRemainingPathVariable(golem_agent_common.PathVariable{value485})
+
+				default:
+					panic("unreachable")
+				}
+
+				result487 = append(result487, variant486)
+			}
+
+			var option488 witTypes.Option[golem_agent_common.AuthDetails]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 30*4)))) {
+			case 0:
+
+				option488 = witTypes.None[golem_agent_common.AuthDetails]()
+			case 1:
+
+				option488 = witTypes.Some[golem_agent_common.AuthDetails](golem_agent_common.AuthDetails{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (9 + 30*4)))) != 0)})
+			default:
+				panic("unreachable")
+			}
+			result490 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 32*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 32*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 31*4))))), index*(2*4))
+				value489 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+				result490 = append(result490, value489)
+			}
+
+			result495 := make([]golem_agent_common.PathSegment, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 34*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 34*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 33*4))))), index*(3*4))
+				var variant494 golem_agent_common.PathSegment
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+					value491 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+					variant494 = golem_agent_common.MakePathSegmentLiteral(value491)
+
+				case 1:
+
+					variant494 = golem_agent_common.MakePathSegmentSystemVariable(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))))
+
+				case 2:
+					value492 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+					variant494 = golem_agent_common.MakePathSegmentPathVariable(golem_agent_common.PathVariable{value492})
+
+				case 3:
+					value493 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+					variant494 = golem_agent_common.MakePathSegmentRemainingPathVariable(golem_agent_common.PathVariable{value493})
+
+				default:
+					panic("unreachable")
+				}
+
+				result495 = append(result495, variant494)
+			}
+
+			option496 = witTypes.Some[golem_agent_common.HttpMountDetails](golem_agent_common.HttpMountDetails{result487, option488, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (10 + 30*4)))) != 0), golem_agent_common.CorsOptions{result490}, result495})
+		default:
+			panic("unreachable")
+		}
+		var variant498 golem_agent_common.Snapshotting
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 34*4)))) {
+		case 0:
+
+			variant498 = golem_agent_common.MakeSnapshottingDisabled()
+
+		case 1:
+			var variant497 golem_agent_common.SnapshottingConfig
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 34*4)))) {
+			case 0:
+
+				variant497 = golem_agent_common.MakeSnapshottingConfigDefault()
+
+			case 1:
+
+				variant497 = golem_agent_common.MakeSnapshottingConfigPeriodic(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (32 + 34*4)))))
+
+			case 2:
+
+				variant497 = golem_agent_common.MakeSnapshottingConfigEveryNInvocation(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (32 + 34*4))))))
+
+			default:
+				panic("unreachable")
+			}
+
+			variant498 = golem_agent_common.MakeSnapshottingEnabled(variant497)
+
+		default:
+			panic("unreachable")
+		}
+		result501 := make([]golem_agent_common.AgentConfigDeclaration, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (40 + 35*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (40 + 35*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (40 + 34*4))))), index*(4*4))
+			result500 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))), index*(2*4))
+				value499 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+				result500 = append(result500, value499)
+			}
+
+			result501 = append(result501, golem_agent_common.AgentConfigDeclaration{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), result500, *(*int32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))})
+		}
+
+		option502 = witTypes.Some[golem_agent_common.RegisteredAgentType](golem_agent_common.RegisteredAgentType{golem_agent_common.AgentType{value, value0, value1, golem_core_types.SchemaGraph{result174, result178, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 10*4)))}, golem_agent_common.AgentConstructor{option180, value181, option183, variant198}, result238, result482, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 26*4))))), option496, variant498, result501}, golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (40 + 36*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (48 + 36*4))))}}})
+	default:
+		panic("unreachable")
+	}
+	result503 := option502
+	return result503
+
+}
+
+//go:wasmimport golem:agent/host@2.0.0 make-agent-id
+func wasm_import_make_agent_id(arg0 uintptr, arg1 uint32, arg2 uintptr, arg3 uint32, arg4 int32, arg5 int32, arg6 int64, arg7 int64, arg8 uintptr)
+
+func MakeAgentId(agentTypeName string, input golem_core_types.SchemaValueTree, phantomId witTypes.Option[golem_core_types.Uuid]) witTypes.Result[string, golem_agent_common.AgentError] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (10 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(agentTypeName))
+	pinner.Pin(utf8)
+	slice25 := (input).ValueNodes
+	length27 := uint32(len(slice25))
+	result26 := witRuntime.Allocate(pinner, uintptr(length27*(16+4*4)), 8)
+	for index, element := range slice25 {
+		base := unsafe.Add(result26, index*(16+4*4))
+
+		switch element.Tag() {
+		case golem_core_types.SchemaValueNodeBoolValue:
+			payload := element.BoolValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case golem_core_types.SchemaValueNodeS8Value:
+			payload := element.S8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS16Value:
+			payload := element.S16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS32Value:
+			payload := element.S32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeS64Value:
+			payload := element.S64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeU8Value:
+			payload := element.U8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU16Value:
+			payload := element.U16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU32Value:
+			payload := element.U32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeU64Value:
+			payload := element.U64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case golem_core_types.SchemaValueNodeF32Value:
+			payload := element.F32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeF64Value:
+			payload := element.F64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeCharValue:
+			payload := element.CharValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeStringValue:
+			payload := element.StringValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case golem_core_types.SchemaValueNodeRecordValue:
+			payload := element.RecordValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			slice := payload
+			length := uint32(len(slice))
+			result1 := witRuntime.Allocate(pinner, uintptr(length*4), 4)
+			for index, element := range slice {
+				base := unsafe.Add(result1, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result1)))
+
+		case golem_core_types.SchemaValueNodeVariantValue:
+			payload := element.VariantValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).Case)
+
+			switch (payload).Payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeEnumValue:
+			payload := element.EnumValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeFlagsValue:
+			payload := element.FlagsValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			slice3 := payload
+			length5 := uint32(len(slice3))
+			result4 := witRuntime.Allocate(pinner, uintptr(length5*1), 1)
+			for index, element := range slice3 {
+				base := unsafe.Add(result4, index*1)
+				var result2 int32
+				if element {
+					result2 = 1
+				} else {
+					result2 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result2)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length5)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result4)))
+
+		case golem_core_types.SchemaValueNodeTupleValue:
+			payload := element.TupleValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			slice6 := payload
+			length8 := uint32(len(slice6))
+			result7 := witRuntime.Allocate(pinner, uintptr(length8*4), 4)
+			for index, element := range slice6 {
+				base := unsafe.Add(result7, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length8)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result7)))
+
+		case golem_core_types.SchemaValueNodeListValue:
+			payload := element.ListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			slice9 := payload
+			length11 := uint32(len(slice9))
+			result10 := witRuntime.Allocate(pinner, uintptr(length11*4), 4)
+			for index, element := range slice9 {
+				base := unsafe.Add(result10, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length11)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result10)))
+
+		case golem_core_types.SchemaValueNodeFixedListValue:
+			payload := element.FixedListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			slice12 := payload
+			length14 := uint32(len(slice12))
+			result13 := witRuntime.Allocate(pinner, uintptr(length14*4), 4)
+			for index, element := range slice12 {
+				base := unsafe.Add(result13, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length14)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result13)))
+
+		case golem_core_types.SchemaValueNodeMapValue:
+			payload := element.MapValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			slice15 := payload
+			length17 := uint32(len(slice15))
+			result16 := witRuntime.Allocate(pinner, uintptr(length17*8), 4)
+			for index, element := range slice15 {
+				base := unsafe.Add(result16, index*8)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).Key
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (element).Value
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length17)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result16)))
+
+		case golem_core_types.SchemaValueNodeOptionValue:
+			payload := element.OptionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeResultValue:
+			payload := element.ResultValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+
+			switch payload.Tag() {
+			case golem_core_types.ResultValuePayloadOkValue:
+				payload := payload.OkValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.ResultValuePayloadErrValue:
+				payload := payload.ErrValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeTextValue:
+			payload := element.TextValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+			utf818 := unsafe.Pointer(unsafe.StringData((payload).Text))
+			pinner.Pin(utf818)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf818)))
+
+			switch (payload).Language.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Language.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf819 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf819)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf819)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeBinaryValue:
+			payload := element.BinaryValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+			data := unsafe.Pointer(unsafe.SliceData((payload).Bytes))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+			switch (payload).MimeType.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MimeType.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf820 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf820)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf820)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodePathValue:
+			payload := element.PathValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			utf821 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf821)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf821)))
+
+		case golem_core_types.SchemaValueNodeUrlValue:
+			payload := element.UrlValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			utf822 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf822)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf822)))
+
+		case golem_core_types.SchemaValueNodeDatetimeValue:
+			payload := element.DatetimeValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = int32((payload).Nanoseconds)
+
+		case golem_core_types.SchemaValueNodeDurationValue:
+			payload := element.DurationValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Nanoseconds
+
+		case golem_core_types.SchemaValueNodeQuantityValueNode:
+			payload := element.QuantityValueNode()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Mantissa
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Scale
+			utf823 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+			pinner.Pin(utf823)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uint32(len((payload).Unit)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))) = uint32(uintptr(uintptr(utf823)))
+
+		case golem_core_types.SchemaValueNodeUnionValue:
+			payload := element.UnionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			utf824 := unsafe.Pointer(unsafe.StringData((payload).Tag))
+			pinner.Pin(utf824)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf824)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Body
+
+		case golem_core_types.SchemaValueNodeSecretValue:
+			payload := element.SecretValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		case golem_core_types.SchemaValueNodeQuotaTokenHandle:
+			payload := element.QuotaTokenHandle()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	var option int32
+	var option28 int64
+	var option29 int64
+	switch phantomId.Tag() {
+	case witTypes.OptionNone:
+
+		option = int32(0)
+		option28 = 0
+		option29 = 0
+	case witTypes.OptionSome:
+		payload := phantomId.Some()
+
+		option = int32(1)
+		option28 = int64((payload).HighBits)
+		option29 = int64((payload).LowBits)
+	default:
+		panic("unreachable")
+	}
+	wasm_import_make_agent_id(uintptr(utf8), uint32(len(agentTypeName)), uintptr(result26), length27, (input).Root, option, option28, option29, returnArea)
+	var result238 witTypes.Result[string, golem_agent_common.AgentError]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result238 = witTypes.Ok[string, golem_agent_common.AgentError](value)
+	case 1:
+		var variant237 golem_agent_common.AgentError
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value30 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant237 = golem_agent_common.MakeAgentErrorInvalidInput(value30)
+
+		case 1:
+			value31 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant237 = golem_agent_common.MakeAgentErrorInvalidMethod(value31)
+
+		case 2:
+			value32 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant237 = golem_agent_common.MakeAgentErrorInvalidType(value32)
+
+		case 3:
+			value33 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant237 = golem_agent_common.MakeAgentErrorInvalidAgentId(value33)
+
+		case 4:
+			result208 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))), index*(56+22*4))
+				var variant196 golem_core_types.SchemaTypeBody
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 1:
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+				case 2:
+					var option39 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option39 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option34 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option34 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option34 = witTypes.Some[golem_core_types.NumericBound](variant)
+						default:
+							panic("unreachable")
+						}
+						var option36 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option36 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant35 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant35 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant35 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant35 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option36 = witTypes.Some[golem_core_types.NumericBound](variant35)
+						default:
+							panic("unreachable")
+						}
+						var option38 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option38 = witTypes.None[string]()
+						case 1:
+							value37 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option38 = witTypes.Some[string](value37)
+						default:
+							panic("unreachable")
+						}
+
+						option39 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option34, option36, option38})
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyS8Type(option39)
+
+				case 3:
+					var option46 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option46 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option41 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option41 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant40 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant40 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant40 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant40 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option41 = witTypes.Some[golem_core_types.NumericBound](variant40)
+						default:
+							panic("unreachable")
+						}
+						var option43 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option43 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant42 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant42 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant42 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant42 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option43 = witTypes.Some[golem_core_types.NumericBound](variant42)
+						default:
+							panic("unreachable")
+						}
+						var option45 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option45 = witTypes.None[string]()
+						case 1:
+							value44 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option45 = witTypes.Some[string](value44)
+						default:
+							panic("unreachable")
+						}
+
+						option46 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option41, option43, option45})
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyS16Type(option46)
+
+				case 4:
+					var option53 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option53 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option48 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option48 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant47 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant47 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant47 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant47 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option48 = witTypes.Some[golem_core_types.NumericBound](variant47)
+						default:
+							panic("unreachable")
+						}
+						var option50 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option50 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant49 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant49 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant49 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant49 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option50 = witTypes.Some[golem_core_types.NumericBound](variant49)
+						default:
+							panic("unreachable")
+						}
+						var option52 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option52 = witTypes.None[string]()
+						case 1:
+							value51 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option52 = witTypes.Some[string](value51)
+						default:
+							panic("unreachable")
+						}
+
+						option53 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option48, option50, option52})
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyS32Type(option53)
+
+				case 5:
+					var option60 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option60 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option55 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option55 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant54 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant54 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant54 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant54 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option55 = witTypes.Some[golem_core_types.NumericBound](variant54)
+						default:
+							panic("unreachable")
+						}
+						var option57 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option57 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant56 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant56 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant56 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant56 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option57 = witTypes.Some[golem_core_types.NumericBound](variant56)
+						default:
+							panic("unreachable")
+						}
+						var option59 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option59 = witTypes.None[string]()
+						case 1:
+							value58 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option59 = witTypes.Some[string](value58)
+						default:
+							panic("unreachable")
+						}
+
+						option60 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option55, option57, option59})
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyS64Type(option60)
+
+				case 6:
+					var option67 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option67 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option62 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option62 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant61 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant61 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant61 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant61 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option62 = witTypes.Some[golem_core_types.NumericBound](variant61)
+						default:
+							panic("unreachable")
+						}
+						var option64 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option64 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant63 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant63 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant63 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant63 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option64 = witTypes.Some[golem_core_types.NumericBound](variant63)
+						default:
+							panic("unreachable")
+						}
+						var option66 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option66 = witTypes.None[string]()
+						case 1:
+							value65 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option66 = witTypes.Some[string](value65)
+						default:
+							panic("unreachable")
+						}
+
+						option67 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option62, option64, option66})
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyU8Type(option67)
+
+				case 7:
+					var option74 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option74 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option69 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option69 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant68 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant68 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant68 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant68 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option69 = witTypes.Some[golem_core_types.NumericBound](variant68)
+						default:
+							panic("unreachable")
+						}
+						var option71 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option71 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant70 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant70 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant70 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant70 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option71 = witTypes.Some[golem_core_types.NumericBound](variant70)
+						default:
+							panic("unreachable")
+						}
+						var option73 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option73 = witTypes.None[string]()
+						case 1:
+							value72 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option73 = witTypes.Some[string](value72)
+						default:
+							panic("unreachable")
+						}
+
+						option74 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option69, option71, option73})
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyU16Type(option74)
+
+				case 8:
+					var option81 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option81 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option76 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option76 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant75 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant75 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant75 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant75 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option76 = witTypes.Some[golem_core_types.NumericBound](variant75)
+						default:
+							panic("unreachable")
+						}
+						var option78 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option78 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant77 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant77 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant77 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant77 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option78 = witTypes.Some[golem_core_types.NumericBound](variant77)
+						default:
+							panic("unreachable")
+						}
+						var option80 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option80 = witTypes.None[string]()
+						case 1:
+							value79 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option80 = witTypes.Some[string](value79)
+						default:
+							panic("unreachable")
+						}
+
+						option81 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option76, option78, option80})
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyU32Type(option81)
+
+				case 9:
+					var option88 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option88 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option83 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option83 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant82 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant82 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant82 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant82 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option83 = witTypes.Some[golem_core_types.NumericBound](variant82)
+						default:
+							panic("unreachable")
+						}
+						var option85 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option85 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant84 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant84 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant84 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant84 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option85 = witTypes.Some[golem_core_types.NumericBound](variant84)
+						default:
+							panic("unreachable")
+						}
+						var option87 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option87 = witTypes.None[string]()
+						case 1:
+							value86 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option87 = witTypes.Some[string](value86)
+						default:
+							panic("unreachable")
+						}
+
+						option88 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option83, option85, option87})
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyU64Type(option88)
+
+				case 10:
+					var option95 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option95 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option90 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option90 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant89 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant89 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant89 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant89 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option90 = witTypes.Some[golem_core_types.NumericBound](variant89)
+						default:
+							panic("unreachable")
+						}
+						var option92 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option92 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant91 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant91 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant91 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant91 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option92 = witTypes.Some[golem_core_types.NumericBound](variant91)
+						default:
+							panic("unreachable")
+						}
+						var option94 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option94 = witTypes.None[string]()
+						case 1:
+							value93 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option94 = witTypes.Some[string](value93)
+						default:
+							panic("unreachable")
+						}
+
+						option95 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option90, option92, option94})
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyF32Type(option95)
+
+				case 11:
+					var option102 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option102 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option97 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option97 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant96 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant96 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant96 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant96 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option97 = witTypes.Some[golem_core_types.NumericBound](variant96)
+						default:
+							panic("unreachable")
+						}
+						var option99 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option99 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant98 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant98 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant98 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant98 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option99 = witTypes.Some[golem_core_types.NumericBound](variant98)
+						default:
+							panic("unreachable")
+						}
+						var option101 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option101 = witTypes.None[string]()
+						case 1:
+							value100 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option101 = witTypes.Some[string](value100)
+						default:
+							panic("unreachable")
+						}
+
+						option102 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option97, option99, option101})
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyF64Type(option102)
+
+				case 12:
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+				case 13:
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+				case 14:
+					result115 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+						value103 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option105 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+						case 0:
+
+							option105 = witTypes.None[string]()
+						case 1:
+							value104 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							option105 = witTypes.Some[string](value104)
+						default:
+							panic("unreachable")
+						}
+						result107 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+							value106 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result107 = append(result107, value106)
+						}
+
+						result109 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+							value108 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result109 = append(result109, value108)
+						}
+
+						var option111 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+						case 0:
+
+							option111 = witTypes.None[string]()
+						case 1:
+							value110 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+							option111 = witTypes.Some[string](value110)
+						default:
+							panic("unreachable")
+						}
+						var option114 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+						case 0:
+
+							option114 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant113 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+							case 0:
+
+								variant113 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant113 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant113 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value112 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+								variant113 = golem_core_types.MakeRoleOther(value112)
+
+							default:
+								panic("unreachable")
+							}
+
+							option114 = witTypes.Some[golem_core_types.Role](variant113)
+						default:
+							panic("unreachable")
+						}
+
+						result115 = append(result115, golem_core_types.NamedFieldType{value103, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option105, result107, result109, option111, option114}})
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyRecordType(result115)
+
+				case 15:
+					result129 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+						value116 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option117 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option117 = witTypes.None[int32]()
+						case 1:
+
+							option117 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+						default:
+							panic("unreachable")
+						}
+						var option119 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option119 = witTypes.None[string]()
+						case 1:
+							value118 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option119 = witTypes.Some[string](value118)
+						default:
+							panic("unreachable")
+						}
+						result121 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+							value120 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result121 = append(result121, value120)
+						}
+
+						result123 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+							value122 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result123 = append(result123, value122)
+						}
+
+						var option125 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+						case 0:
+
+							option125 = witTypes.None[string]()
+						case 1:
+							value124 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+							option125 = witTypes.Some[string](value124)
+						default:
+							panic("unreachable")
+						}
+						var option128 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+						case 0:
+
+							option128 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant127 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+							case 0:
+
+								variant127 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant127 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant127 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value126 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+								variant127 = golem_core_types.MakeRoleOther(value126)
+
+							default:
+								panic("unreachable")
+							}
+
+							option128 = witTypes.Some[golem_core_types.Role](variant127)
+						default:
+							panic("unreachable")
+						}
+
+						result129 = append(result129, golem_core_types.VariantCaseType{value116, option117, golem_core_types.MetadataEnvelope{option119, result121, result123, option125, option128}})
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyVariantType(result129)
+
+				case 16:
+					result131 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+						value130 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result131 = append(result131, value130)
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyEnumType(result131)
+
+				case 17:
+					result133 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+						value132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result133 = append(result133, value132)
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyFlagsType(result133)
+
+				case 18:
+					result134 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result134 = append(result134, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyTupleType(result134)
+
+				case 19:
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 20:
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+				case 21:
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+				case 22:
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 23:
+					var option135 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option135 = witTypes.None[int32]()
+					case 1:
+
+						option135 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+					var option136 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option136 = witTypes.None[int32]()
+					case 1:
+
+						option136 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option135, option136})
+
+				case 24:
+					var option139 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option139 = witTypes.None[[]string]()
+					case 1:
+						result138 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+							value137 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result138 = append(result138, value137)
+						}
+
+						option139 = witTypes.Some[[]string](result138)
+					default:
+						panic("unreachable")
+					}
+					var option140 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+					case 0:
+
+						option140 = witTypes.None[uint32]()
+					case 1:
+
+						option140 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+					var option141 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+					case 0:
+
+						option141 = witTypes.None[uint32]()
+					case 1:
+
+						option141 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+					var option143 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+					case 0:
+
+						option143 = witTypes.None[string]()
+					case 1:
+						value142 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+						option143 = witTypes.Some[string](value142)
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option139, option140, option141, option143})
+
+				case 25:
+					var option146 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option146 = witTypes.None[[]string]()
+					case 1:
+						result145 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+							value144 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result145 = append(result145, value144)
+						}
+
+						option146 = witTypes.Some[[]string](result145)
+					default:
+						panic("unreachable")
+					}
+					var option147 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+					case 0:
+
+						option147 = witTypes.None[uint32]()
+					case 1:
+
+						option147 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+					var option148 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+					case 0:
+
+						option148 = witTypes.None[uint32]()
+					case 1:
+
+						option148 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option146, option147, option148})
+
+				case 26:
+					var option151 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+					case 0:
+
+						option151 = witTypes.None[[]string]()
+					case 1:
+						result150 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+							value149 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result150 = append(result150, value149)
+						}
+
+						option151 = witTypes.Some[[]string](result150)
+					default:
+						panic("unreachable")
+					}
+					var option154 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+					case 0:
+
+						option154 = witTypes.None[[]string]()
+					case 1:
+						result153 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+							value152 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result153 = append(result153, value152)
+						}
+
+						option154 = witTypes.Some[[]string](result153)
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option151, option154})
+
+				case 27:
+					var option157 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option157 = witTypes.None[[]string]()
+					case 1:
+						result156 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+							value155 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result156 = append(result156, value155)
+						}
+
+						option157 = witTypes.Some[[]string](result156)
+					default:
+						panic("unreachable")
+					}
+					var option160 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+					case 0:
+
+						option160 = witTypes.None[[]string]()
+					case 1:
+						result159 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+							value158 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result159 = append(result159, value158)
+						}
+
+						option160 = witTypes.Some[[]string](result159)
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option157, option160})
+
+				case 28:
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+				case 29:
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+				case 30:
+					value161 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					result163 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+						value162 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result163 = append(result163, value162)
+					}
+
+					var option165 witTypes.Option[golem_core_types.QuantityValue]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+					case 0:
+
+						option165 = witTypes.None[golem_core_types.QuantityValue]()
+					case 1:
+						value164 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+						option165 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value164})
+					default:
+						panic("unreachable")
+					}
+					var option167 witTypes.Option[golem_core_types.QuantityValue]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+					case 0:
+
+						option167 = witTypes.None[golem_core_types.QuantityValue]()
+					case 1:
+						value166 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+						option167 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value166})
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value161, result163, option165, option167})
+
+				case 31:
+					result189 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+						value168 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var variant177 golem_core_types.DiscriminatorRule
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+						case 0:
+							value169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant177 = golem_core_types.MakeDiscriminatorRulePrefix(value169)
+
+						case 1:
+							value170 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant177 = golem_core_types.MakeDiscriminatorRuleSuffix(value170)
+
+						case 2:
+							value171 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant177 = golem_core_types.MakeDiscriminatorRuleContains(value171)
+
+						case 3:
+							value172 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant177 = golem_core_types.MakeDiscriminatorRuleRegex(value172)
+
+						case 4:
+							value173 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+							var option175 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+							case 0:
+
+								option175 = witTypes.None[string]()
+							case 1:
+								value174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+								option175 = witTypes.Some[string](value174)
+							default:
+								panic("unreachable")
+							}
+
+							variant177 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value173, option175})
+
+						case 5:
+							value176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant177 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value176)
+
+						default:
+							panic("unreachable")
+						}
+						var option179 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+						case 0:
+
+							option179 = witTypes.None[string]()
+						case 1:
+							value178 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+							option179 = witTypes.Some[string](value178)
+						default:
+							panic("unreachable")
+						}
+						result181 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+							value180 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result181 = append(result181, value180)
+						}
+
+						result183 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+							value182 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result183 = append(result183, value182)
+						}
+
+						var option185 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+						case 0:
+
+							option185 = witTypes.None[string]()
+						case 1:
+							value184 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+							option185 = witTypes.Some[string](value184)
+						default:
+							panic("unreachable")
+						}
+						var option188 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+						case 0:
+
+							option188 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant187 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+							case 0:
+
+								variant187 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant187 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant187 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+								variant187 = golem_core_types.MakeRoleOther(value186)
+
+							default:
+								panic("unreachable")
+							}
+
+							option188 = witTypes.Some[golem_core_types.Role](variant187)
+						default:
+							panic("unreachable")
+						}
+
+						result189 = append(result189, golem_core_types.UnionBranch{value168, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant177, golem_core_types.MetadataEnvelope{option179, result181, result183, option185, option188}})
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result189})
+
+				case 32:
+					var option191 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+					case 0:
+
+						option191 = witTypes.None[string]()
+					case 1:
+						value190 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						option191 = witTypes.Some[string](value190)
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option191})
+
+				case 33:
+					var option193 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option193 = witTypes.None[string]()
+					case 1:
+						value192 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+						option193 = witTypes.Some[string](value192)
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option193})
+
+				case 34:
+					var option194 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option194 = witTypes.None[int32]()
+					case 1:
+
+						option194 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyFutureType(option194)
+
+				case 35:
+					var option195 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option195 = witTypes.None[int32]()
+					case 1:
+
+						option195 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+
+					variant196 = golem_core_types.MakeSchemaTypeBodyStreamType(option195)
+
+				default:
+					panic("unreachable")
+				}
+				var option198 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+				case 0:
+
+					option198 = witTypes.None[string]()
+				case 1:
+					value197 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+					option198 = witTypes.Some[string](value197)
+				default:
+					panic("unreachable")
+				}
+				result200 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+					value199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result200 = append(result200, value199)
+				}
+
+				result202 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+					value201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result202 = append(result202, value201)
+				}
+
+				var option204 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+				case 0:
+
+					option204 = witTypes.None[string]()
+				case 1:
+					value203 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+					option204 = witTypes.Some[string](value203)
+				default:
+					panic("unreachable")
+				}
+				var option207 witTypes.Option[golem_core_types.Role]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+				case 0:
+
+					option207 = witTypes.None[golem_core_types.Role]()
+				case 1:
+					var variant206 golem_core_types.Role
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+					case 0:
+
+						variant206 = golem_core_types.MakeRoleMultimodal()
+
+					case 1:
+
+						variant206 = golem_core_types.MakeRoleUnstructuredText()
+
+					case 2:
+
+						variant206 = golem_core_types.MakeRoleUnstructuredBinary()
+
+					case 3:
+						value205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+						variant206 = golem_core_types.MakeRoleOther(value205)
+
+					default:
+						panic("unreachable")
+					}
+
+					option207 = witTypes.Some[golem_core_types.Role](variant206)
+				default:
+					panic("unreachable")
+				}
+
+				result208 = append(result208, golem_core_types.SchemaTypeNode{variant196, golem_core_types.MetadataEnvelope{option198, result200, result202, option204, option207}})
+			}
+
+			result212 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))), index*(6*4))
+				value209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+				var option211 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+				case 0:
+
+					option211 = witTypes.None[string]()
+				case 1:
+					value210 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+					option211 = witTypes.Some[string](value210)
+				default:
+					panic("unreachable")
+				}
+
+				result212 = append(result212, golem_core_types.SchemaTypeDef{value209, option211, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+			}
+
+			result236 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (7 * 4))))), index*(16+4*4))
+				var variant235 golem_core_types.SchemaValueNode
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+				case 1:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 2:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 3:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 4:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 5:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 6:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 7:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 8:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 9:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 10:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 11:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 12:
+					value213 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant235 = golem_core_types.MakeSchemaValueNodeStringValue(value213)
+
+				case 13:
+					result214 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result214 = append(result214, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant235 = golem_core_types.MakeSchemaValueNodeRecordValue(result214)
+
+				case 14:
+					var option215 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+					case 0:
+
+						option215 = witTypes.None[int32]()
+					case 1:
+
+						option215 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+					default:
+						panic("unreachable")
+					}
+
+					variant235 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option215})
+
+				case 15:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 16:
+					result216 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+						result216 = append(result216, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+					}
+
+					variant235 = golem_core_types.MakeSchemaValueNodeFlagsValue(result216)
+
+				case 17:
+					result217 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result217 = append(result217, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant235 = golem_core_types.MakeSchemaValueNodeTupleValue(result217)
+
+				case 18:
+					result218 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result218 = append(result218, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant235 = golem_core_types.MakeSchemaValueNodeListValue(result218)
+
+				case 19:
+					result219 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result219 = append(result219, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant235 = golem_core_types.MakeSchemaValueNodeFixedListValue(result219)
+
+				case 20:
+					result220 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+						result220 = append(result220, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+					}
+
+					variant235 = golem_core_types.MakeSchemaValueNodeMapValue(result220)
+
+				case 21:
+					var option221 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option221 = witTypes.None[int32]()
+					case 1:
+
+						option221 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+
+					variant235 = golem_core_types.MakeSchemaValueNodeOptionValue(option221)
+
+				case 22:
+					var variant224 golem_core_types.ResultValuePayload
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+						var option222 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+						case 0:
+
+							option222 = witTypes.None[int32]()
+						case 1:
+
+							option222 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+						default:
+							panic("unreachable")
+						}
+
+						variant224 = golem_core_types.MakeResultValuePayloadOkValue(option222)
+
+					case 1:
+						var option223 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+						case 0:
+
+							option223 = witTypes.None[int32]()
+						case 1:
+
+							option223 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+						default:
+							panic("unreachable")
+						}
+
+						variant224 = golem_core_types.MakeResultValuePayloadErrValue(option223)
+
+					default:
+						panic("unreachable")
+					}
+
+					variant235 = golem_core_types.MakeSchemaValueNodeResultValue(variant224)
+
+				case 23:
+					value225 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					var option227 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						option227 = witTypes.None[string]()
+					case 1:
+						value226 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+						option227 = witTypes.Some[string](value226)
+					default:
+						panic("unreachable")
+					}
+
+					variant235 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value225, option227})
+
+				case 24:
+					value228 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					var option230 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						option230 = witTypes.None[string]()
+					case 1:
+						value229 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+						option230 = witTypes.Some[string](value229)
+					default:
+						panic("unreachable")
+					}
+
+					variant235 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value228, option230})
+
+				case 25:
+					value231 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant235 = golem_core_types.MakeSchemaValueNodePathValue(value231)
+
+				case 26:
+					value232 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant235 = golem_core_types.MakeSchemaValueNodeUrlValue(value232)
+
+				case 27:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+				case 28:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+				case 29:
+					value233 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+					variant235 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value233})
+
+				case 30:
+					value234 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant235 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value234, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+				case 31:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+				case 32:
+
+					variant235 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+				default:
+					panic("unreachable")
+				}
+
+				result236 = append(result236, variant235)
+			}
+
+			variant237 = golem_agent_common.MakeAgentErrorCustomError(golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result208, result212, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (6 * 4)))}, golem_core_types.SchemaValueTree{result236, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (9 * 4)))}})
+
+		default:
+			panic("unreachable")
+		}
+
+		result238 = witTypes.Err[string, golem_agent_common.AgentError](variant237)
+	default:
+		panic("unreachable")
+	}
+	result239 := result238
+	return result239
+
+}
+
+//go:wasmimport golem:agent/host@2.0.0 parse-agent-id
+func wasm_import_parse_agent_id(arg0 uintptr, arg1 uint32, arg2 uintptr)
+
+func ParseAgentId(agentId string) witTypes.Result[witTypes.Tuple3[string, golem_core_types.TypedSchemaValue, witTypes.Option[golem_core_types.Uuid]], golem_agent_common.AgentError] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (32 + 10*4), 8))
+	utf8 := unsafe.Pointer(unsafe.StringData(agentId))
+	pinner.Pin(utf8)
+	wasm_import_parse_agent_id(uintptr(utf8), uint32(len(agentId)), returnArea)
+	var result411 witTypes.Result[witTypes.Tuple3[string, golem_core_types.TypedSchemaValue, witTypes.Option[golem_core_types.Uuid]], golem_agent_common.AgentError]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+		result172 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))), index*(56+22*4))
+			var variant160 golem_core_types.SchemaTypeBody
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 1:
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+			case 2:
+				var option4 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option4 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option = witTypes.Some[golem_core_types.NumericBound](variant)
+					default:
+						panic("unreachable")
+					}
+					var option1 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option1 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant0 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant0 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant0 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant0 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option1 = witTypes.Some[golem_core_types.NumericBound](variant0)
+					default:
+						panic("unreachable")
+					}
+					var option3 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option3 = witTypes.None[string]()
+					case 1:
+						value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option3 = witTypes.Some[string](value2)
+					default:
+						panic("unreachable")
+					}
+
+					option4 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option, option1, option3})
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyS8Type(option4)
+
+			case 3:
+				var option11 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option11 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option6 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option6 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant5 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant5 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant5 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant5 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option6 = witTypes.Some[golem_core_types.NumericBound](variant5)
+					default:
+						panic("unreachable")
+					}
+					var option8 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option8 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant7 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant7 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant7 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant7 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option8 = witTypes.Some[golem_core_types.NumericBound](variant7)
+					default:
+						panic("unreachable")
+					}
+					var option10 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option10 = witTypes.None[string]()
+					case 1:
+						value9 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option10 = witTypes.Some[string](value9)
+					default:
+						panic("unreachable")
+					}
+
+					option11 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option6, option8, option10})
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyS16Type(option11)
+
+			case 4:
+				var option18 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option18 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option13 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option13 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant12 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant12 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant12 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant12 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option13 = witTypes.Some[golem_core_types.NumericBound](variant12)
+					default:
+						panic("unreachable")
+					}
+					var option15 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option15 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant14 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant14 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant14 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant14 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option15 = witTypes.Some[golem_core_types.NumericBound](variant14)
+					default:
+						panic("unreachable")
+					}
+					var option17 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option17 = witTypes.None[string]()
+					case 1:
+						value16 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option17 = witTypes.Some[string](value16)
+					default:
+						panic("unreachable")
+					}
+
+					option18 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option13, option15, option17})
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyS32Type(option18)
+
+			case 5:
+				var option25 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option25 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option20 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option20 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant19 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant19 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant19 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant19 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option20 = witTypes.Some[golem_core_types.NumericBound](variant19)
+					default:
+						panic("unreachable")
+					}
+					var option22 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option22 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant21 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant21 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant21 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant21 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option22 = witTypes.Some[golem_core_types.NumericBound](variant21)
+					default:
+						panic("unreachable")
+					}
+					var option24 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option24 = witTypes.None[string]()
+					case 1:
+						value23 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option24 = witTypes.Some[string](value23)
+					default:
+						panic("unreachable")
+					}
+
+					option25 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option20, option22, option24})
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyS64Type(option25)
+
+			case 6:
+				var option32 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option32 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option27 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option27 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant26 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant26 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant26 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant26 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option27 = witTypes.Some[golem_core_types.NumericBound](variant26)
+					default:
+						panic("unreachable")
+					}
+					var option29 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option29 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant28 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant28 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant28 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant28 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option29 = witTypes.Some[golem_core_types.NumericBound](variant28)
+					default:
+						panic("unreachable")
+					}
+					var option31 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option31 = witTypes.None[string]()
+					case 1:
+						value30 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option31 = witTypes.Some[string](value30)
+					default:
+						panic("unreachable")
+					}
+
+					option32 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option27, option29, option31})
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyU8Type(option32)
+
+			case 7:
+				var option39 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option39 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option34 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option34 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant33 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant33 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant33 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant33 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option34 = witTypes.Some[golem_core_types.NumericBound](variant33)
+					default:
+						panic("unreachable")
+					}
+					var option36 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option36 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant35 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant35 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant35 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant35 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option36 = witTypes.Some[golem_core_types.NumericBound](variant35)
+					default:
+						panic("unreachable")
+					}
+					var option38 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option38 = witTypes.None[string]()
+					case 1:
+						value37 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option38 = witTypes.Some[string](value37)
+					default:
+						panic("unreachable")
+					}
+
+					option39 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option34, option36, option38})
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyU16Type(option39)
+
+			case 8:
+				var option46 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option46 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option41 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option41 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant40 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant40 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant40 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant40 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option41 = witTypes.Some[golem_core_types.NumericBound](variant40)
+					default:
+						panic("unreachable")
+					}
+					var option43 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option43 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant42 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant42 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant42 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant42 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option43 = witTypes.Some[golem_core_types.NumericBound](variant42)
+					default:
+						panic("unreachable")
+					}
+					var option45 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option45 = witTypes.None[string]()
+					case 1:
+						value44 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option45 = witTypes.Some[string](value44)
+					default:
+						panic("unreachable")
+					}
+
+					option46 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option41, option43, option45})
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyU32Type(option46)
+
+			case 9:
+				var option53 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option53 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option48 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option48 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant47 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant47 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant47 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant47 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option48 = witTypes.Some[golem_core_types.NumericBound](variant47)
+					default:
+						panic("unreachable")
+					}
+					var option50 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option50 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant49 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant49 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant49 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant49 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option50 = witTypes.Some[golem_core_types.NumericBound](variant49)
+					default:
+						panic("unreachable")
+					}
+					var option52 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option52 = witTypes.None[string]()
+					case 1:
+						value51 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option52 = witTypes.Some[string](value51)
+					default:
+						panic("unreachable")
+					}
+
+					option53 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option48, option50, option52})
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyU64Type(option53)
+
+			case 10:
+				var option60 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option60 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option55 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option55 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant54 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant54 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant54 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant54 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option55 = witTypes.Some[golem_core_types.NumericBound](variant54)
+					default:
+						panic("unreachable")
+					}
+					var option57 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option57 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant56 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant56 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant56 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant56 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option57 = witTypes.Some[golem_core_types.NumericBound](variant56)
+					default:
+						panic("unreachable")
+					}
+					var option59 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option59 = witTypes.None[string]()
+					case 1:
+						value58 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option59 = witTypes.Some[string](value58)
+					default:
+						panic("unreachable")
+					}
+
+					option60 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option55, option57, option59})
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyF32Type(option60)
+
+			case 11:
+				var option67 witTypes.Option[golem_core_types.NumericRestrictions]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option67 = witTypes.None[golem_core_types.NumericRestrictions]()
+				case 1:
+					var option62 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option62 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant61 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+						case 0:
+
+							variant61 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+						case 1:
+
+							variant61 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						case 2:
+
+							variant61 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option62 = witTypes.Some[golem_core_types.NumericBound](variant61)
+					default:
+						panic("unreachable")
+					}
+					var option64 witTypes.Option[golem_core_types.NumericBound]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+					case 0:
+
+						option64 = witTypes.None[golem_core_types.NumericBound]()
+					case 1:
+						var variant63 golem_core_types.NumericBound
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+						case 0:
+
+							variant63 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+						case 1:
+
+							variant63 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						case 2:
+
+							variant63 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+						default:
+							panic("unreachable")
+						}
+
+						option64 = witTypes.Some[golem_core_types.NumericBound](variant63)
+					default:
+						panic("unreachable")
+					}
+					var option66 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+					case 0:
+
+						option66 = witTypes.None[string]()
+					case 1:
+						value65 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+						option66 = witTypes.Some[string](value65)
+					default:
+						panic("unreachable")
+					}
+
+					option67 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option62, option64, option66})
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyF64Type(option67)
+
+			case 12:
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+			case 13:
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+			case 14:
+				result79 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+					value68 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var option70 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+					case 0:
+
+						option70 = witTypes.None[string]()
+					case 1:
+						value69 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						option70 = witTypes.Some[string](value69)
+					default:
+						panic("unreachable")
+					}
+					result := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+						value71 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result = append(result, value71)
+					}
+
+					result73 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+						value72 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result73 = append(result73, value72)
+					}
+
+					var option75 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+					case 0:
+
+						option75 = witTypes.None[string]()
+					case 1:
+						value74 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+						option75 = witTypes.Some[string](value74)
+					default:
+						panic("unreachable")
+					}
+					var option78 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+					case 0:
+
+						option78 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant77 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+						case 0:
+
+							variant77 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant77 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant77 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value76 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+							variant77 = golem_core_types.MakeRoleOther(value76)
+
+						default:
+							panic("unreachable")
+						}
+
+						option78 = witTypes.Some[golem_core_types.Role](variant77)
+					default:
+						panic("unreachable")
+					}
+
+					result79 = append(result79, golem_core_types.NamedFieldType{value68, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option70, result, result73, option75, option78}})
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyRecordType(result79)
+
+			case 15:
+				result93 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+					value80 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var option81 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+
+						option81 = witTypes.None[int32]()
+					case 1:
+
+						option81 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+					default:
+						panic("unreachable")
+					}
+					var option83 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						option83 = witTypes.None[string]()
+					case 1:
+						value82 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+						option83 = witTypes.Some[string](value82)
+					default:
+						panic("unreachable")
+					}
+					result85 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+						value84 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result85 = append(result85, value84)
+					}
+
+					result87 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+						value86 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result87 = append(result87, value86)
+					}
+
+					var option89 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+					case 0:
+
+						option89 = witTypes.None[string]()
+					case 1:
+						value88 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+						option89 = witTypes.Some[string](value88)
+					default:
+						panic("unreachable")
+					}
+					var option92 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+					case 0:
+
+						option92 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant91 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+						case 0:
+
+							variant91 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant91 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant91 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value90 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+							variant91 = golem_core_types.MakeRoleOther(value90)
+
+						default:
+							panic("unreachable")
+						}
+
+						option92 = witTypes.Some[golem_core_types.Role](variant91)
+					default:
+						panic("unreachable")
+					}
+
+					result93 = append(result93, golem_core_types.VariantCaseType{value80, option81, golem_core_types.MetadataEnvelope{option83, result85, result87, option89, option92}})
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyVariantType(result93)
+
+			case 16:
+				result95 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+					value94 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result95 = append(result95, value94)
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyEnumType(result95)
+
+			case 17:
+				result97 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+					value96 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result97 = append(result97, value96)
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyFlagsType(result97)
+
+			case 18:
+				result98 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result98 = append(result98, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyTupleType(result98)
+
+			case 19:
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 20:
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+			case 21:
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 22:
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 23:
+				var option99 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option99 = witTypes.None[int32]()
+				case 1:
+
+					option99 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+				default:
+					panic("unreachable")
+				}
+				var option100 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+				case 0:
+
+					option100 = witTypes.None[int32]()
+				case 1:
+
+					option100 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option99, option100})
+
+			case 24:
+				var option103 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option103 = witTypes.None[[]string]()
+				case 1:
+					result102 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+						value101 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result102 = append(result102, value101)
+					}
+
+					option103 = witTypes.Some[[]string](result102)
+				default:
+					panic("unreachable")
+				}
+				var option104 witTypes.Option[uint32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+				case 0:
+
+					option104 = witTypes.None[uint32]()
+				case 1:
+
+					option104 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+				default:
+					panic("unreachable")
+				}
+				var option105 witTypes.Option[uint32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+				case 0:
+
+					option105 = witTypes.None[uint32]()
+				case 1:
+
+					option105 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+				default:
+					panic("unreachable")
+				}
+				var option107 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+				case 0:
+
+					option107 = witTypes.None[string]()
+				case 1:
+					value106 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+					option107 = witTypes.Some[string](value106)
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option103, option104, option105, option107})
+
+			case 25:
+				var option110 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option110 = witTypes.None[[]string]()
+				case 1:
+					result109 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+						value108 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result109 = append(result109, value108)
+					}
+
+					option110 = witTypes.Some[[]string](result109)
+				default:
+					panic("unreachable")
+				}
+				var option111 witTypes.Option[uint32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+				case 0:
+
+					option111 = witTypes.None[uint32]()
+				case 1:
+
+					option111 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+				default:
+					panic("unreachable")
+				}
+				var option112 witTypes.Option[uint32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+				case 0:
+
+					option112 = witTypes.None[uint32]()
+				case 1:
+
+					option112 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option110, option111, option112})
+
+			case 26:
+				var option115 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+				case 0:
+
+					option115 = witTypes.None[[]string]()
+				case 1:
+					result114 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+						value113 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result114 = append(result114, value113)
+					}
+
+					option115 = witTypes.Some[[]string](result114)
+				default:
+					panic("unreachable")
+				}
+				var option118 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+				case 0:
+
+					option118 = witTypes.None[[]string]()
+				case 1:
+					result117 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+						value116 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result117 = append(result117, value116)
+					}
+
+					option118 = witTypes.Some[[]string](result117)
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option115, option118})
+
+			case 27:
+				var option121 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option121 = witTypes.None[[]string]()
+				case 1:
+					result120 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+						value119 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result120 = append(result120, value119)
+					}
+
+					option121 = witTypes.Some[[]string](result120)
+				default:
+					panic("unreachable")
+				}
+				var option124 witTypes.Option[[]string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+				case 0:
+
+					option124 = witTypes.None[[]string]()
+				case 1:
+					result123 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+						value122 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result123 = append(result123, value122)
+					}
+
+					option124 = witTypes.Some[[]string](result123)
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option121, option124})
+
+			case 28:
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+			case 29:
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+			case 30:
+				value125 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				result127 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+					value126 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result127 = append(result127, value126)
+				}
+
+				var option129 witTypes.Option[golem_core_types.QuantityValue]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+				case 0:
+
+					option129 = witTypes.None[golem_core_types.QuantityValue]()
+				case 1:
+					value128 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+					option129 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value128})
+				default:
+					panic("unreachable")
+				}
+				var option131 witTypes.Option[golem_core_types.QuantityValue]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+				case 0:
+
+					option131 = witTypes.None[golem_core_types.QuantityValue]()
+				case 1:
+					value130 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+					option131 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value130})
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value125, result127, option129, option131})
+
+			case 31:
+				result153 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+					value132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var variant141 golem_core_types.DiscriminatorRule
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+					case 0:
+						value133 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						variant141 = golem_core_types.MakeDiscriminatorRulePrefix(value133)
+
+					case 1:
+						value134 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						variant141 = golem_core_types.MakeDiscriminatorRuleSuffix(value134)
+
+					case 2:
+						value135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						variant141 = golem_core_types.MakeDiscriminatorRuleContains(value135)
+
+					case 3:
+						value136 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						variant141 = golem_core_types.MakeDiscriminatorRuleRegex(value136)
+
+					case 4:
+						value137 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+						var option139 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+						case 0:
+
+							option139 = witTypes.None[string]()
+						case 1:
+							value138 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+							option139 = witTypes.Some[string](value138)
+						default:
+							panic("unreachable")
+						}
+
+						variant141 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value137, option139})
+
+					case 5:
+						value140 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+						variant141 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value140)
+
+					default:
+						panic("unreachable")
+					}
+					var option143 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+					case 0:
+
+						option143 = witTypes.None[string]()
+					case 1:
+						value142 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+						option143 = witTypes.Some[string](value142)
+					default:
+						panic("unreachable")
+					}
+					result145 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+						value144 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result145 = append(result145, value144)
+					}
+
+					result147 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+						value146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result147 = append(result147, value146)
+					}
+
+					var option149 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+					case 0:
+
+						option149 = witTypes.None[string]()
+					case 1:
+						value148 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+						option149 = witTypes.Some[string](value148)
+					default:
+						panic("unreachable")
+					}
+					var option152 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+					case 0:
+
+						option152 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant151 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+						case 0:
+
+							variant151 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant151 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant151 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value150 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+							variant151 = golem_core_types.MakeRoleOther(value150)
+
+						default:
+							panic("unreachable")
+						}
+
+						option152 = witTypes.Some[golem_core_types.Role](variant151)
+					default:
+						panic("unreachable")
+					}
+
+					result153 = append(result153, golem_core_types.UnionBranch{value132, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant141, golem_core_types.MetadataEnvelope{option143, result145, result147, option149, option152}})
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result153})
+
+			case 32:
+				var option155 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+				case 0:
+
+					option155 = witTypes.None[string]()
+				case 1:
+					value154 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+					option155 = witTypes.Some[string](value154)
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option155})
+
+			case 33:
+				var option157 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option157 = witTypes.None[string]()
+				case 1:
+					value156 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+					option157 = witTypes.Some[string](value156)
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option157})
+
+			case 34:
+				var option158 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option158 = witTypes.None[int32]()
+				case 1:
+
+					option158 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyFutureType(option158)
+
+			case 35:
+				var option159 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option159 = witTypes.None[int32]()
+				case 1:
+
+					option159 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+				default:
+					panic("unreachable")
+				}
+
+				variant160 = golem_core_types.MakeSchemaTypeBodyStreamType(option159)
+
+			default:
+				panic("unreachable")
+			}
+			var option162 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+			case 0:
+
+				option162 = witTypes.None[string]()
+			case 1:
+				value161 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+				option162 = witTypes.Some[string](value161)
+			default:
+				panic("unreachable")
+			}
+			result164 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+				value163 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+				result164 = append(result164, value163)
+			}
+
+			result166 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+				value165 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+				result166 = append(result166, value165)
+			}
+
+			var option168 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+			case 0:
+
+				option168 = witTypes.None[string]()
+			case 1:
+				value167 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+				option168 = witTypes.Some[string](value167)
+			default:
+				panic("unreachable")
+			}
+			var option171 witTypes.Option[golem_core_types.Role]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+			case 0:
+
+				option171 = witTypes.None[golem_core_types.Role]()
+			case 1:
+				var variant170 golem_core_types.Role
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+				case 0:
+
+					variant170 = golem_core_types.MakeRoleMultimodal()
+
+				case 1:
+
+					variant170 = golem_core_types.MakeRoleUnstructuredText()
+
+				case 2:
+
+					variant170 = golem_core_types.MakeRoleUnstructuredBinary()
+
+				case 3:
+					value169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+					variant170 = golem_core_types.MakeRoleOther(value169)
+
+				default:
+					panic("unreachable")
+				}
+
+				option171 = witTypes.Some[golem_core_types.Role](variant170)
+			default:
+				panic("unreachable")
+			}
+
+			result172 = append(result172, golem_core_types.SchemaTypeNode{variant160, golem_core_types.MetadataEnvelope{option162, result164, result166, option168, option171}})
+		}
+
+		result176 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 5*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 5*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 4*4))))), index*(6*4))
+			value173 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			var option175 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+			case 0:
+
+				option175 = witTypes.None[string]()
+			case 1:
+				value174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+				option175 = witTypes.Some[string](value174)
+			default:
+				panic("unreachable")
+			}
+
+			result176 = append(result176, golem_core_types.SchemaTypeDef{value173, option175, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+		}
+
+		result200 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 8*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 8*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 7*4))))), index*(16+4*4))
+			var variant199 golem_core_types.SchemaValueNode
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+			case 1:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 2:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 3:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 4:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 5:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 6:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 7:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 8:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 9:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 10:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 11:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 12:
+				value177 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant199 = golem_core_types.MakeSchemaValueNodeStringValue(value177)
+
+			case 13:
+				result178 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result178 = append(result178, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant199 = golem_core_types.MakeSchemaValueNodeRecordValue(result178)
+
+			case 14:
+				var option179 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+				case 0:
+
+					option179 = witTypes.None[int32]()
+				case 1:
+
+					option179 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+				default:
+					panic("unreachable")
+				}
+
+				variant199 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option179})
+
+			case 15:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 16:
+				result180 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+					result180 = append(result180, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+				}
+
+				variant199 = golem_core_types.MakeSchemaValueNodeFlagsValue(result180)
+
+			case 17:
+				result181 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result181 = append(result181, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant199 = golem_core_types.MakeSchemaValueNodeTupleValue(result181)
+
+			case 18:
+				result182 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result182 = append(result182, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant199 = golem_core_types.MakeSchemaValueNodeListValue(result182)
+
+			case 19:
+				result183 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result183 = append(result183, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant199 = golem_core_types.MakeSchemaValueNodeFixedListValue(result183)
+
+			case 20:
+				result184 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+					result184 = append(result184, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+				}
+
+				variant199 = golem_core_types.MakeSchemaValueNodeMapValue(result184)
+
+			case 21:
+				var option185 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option185 = witTypes.None[int32]()
+				case 1:
+
+					option185 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+				default:
+					panic("unreachable")
+				}
+
+				variant199 = golem_core_types.MakeSchemaValueNodeOptionValue(option185)
+
+			case 22:
+				var variant188 golem_core_types.ResultValuePayload
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+					var option186 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+					case 0:
+
+						option186 = witTypes.None[int32]()
+					case 1:
+
+						option186 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+					default:
+						panic("unreachable")
+					}
+
+					variant188 = golem_core_types.MakeResultValuePayloadOkValue(option186)
+
+				case 1:
+					var option187 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+					case 0:
+
+						option187 = witTypes.None[int32]()
+					case 1:
+
+						option187 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+					default:
+						panic("unreachable")
+					}
+
+					variant188 = golem_core_types.MakeResultValuePayloadErrValue(option187)
+
+				default:
+					panic("unreachable")
+				}
+
+				variant199 = golem_core_types.MakeSchemaValueNodeResultValue(variant188)
+
+			case 23:
+				value189 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var option191 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+
+					option191 = witTypes.None[string]()
+				case 1:
+					value190 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+					option191 = witTypes.Some[string](value190)
+				default:
+					panic("unreachable")
+				}
+
+				variant199 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value189, option191})
+
+			case 24:
+				value192 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var option194 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+
+					option194 = witTypes.None[string]()
+				case 1:
+					value193 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+					option194 = witTypes.Some[string](value193)
+				default:
+					panic("unreachable")
+				}
+
+				variant199 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value192, option194})
+
+			case 25:
+				value195 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant199 = golem_core_types.MakeSchemaValueNodePathValue(value195)
+
+			case 26:
+				value196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant199 = golem_core_types.MakeSchemaValueNodeUrlValue(value196)
+
+			case 27:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+			case 28:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+			case 29:
+				value197 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				variant199 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value197})
+
+			case 30:
+				value198 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant199 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value198, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+			case 31:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+			case 32:
+
+				variant199 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+			default:
+				panic("unreachable")
+			}
+
+			result200 = append(result200, variant199)
+		}
+
+		var option201 witTypes.Option[golem_core_types.Uuid]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 10*4)))) {
+		case 0:
+
+			option201 = witTypes.None[golem_core_types.Uuid]()
+		case 1:
+
+			option201 = witTypes.Some[golem_core_types.Uuid](golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 10*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 10*4))))})
+		default:
+			panic("unreachable")
+		}
+
+		result411 = witTypes.Ok[witTypes.Tuple3[string, golem_core_types.TypedSchemaValue, witTypes.Option[golem_core_types.Uuid]], golem_agent_common.AgentError](witTypes.Tuple3[string, golem_core_types.TypedSchemaValue, witTypes.Option[golem_core_types.Uuid]]{value, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result172, result176, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 6*4)))}, golem_core_types.SchemaValueTree{result200, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 9*4)))}}, option201})
+	case 1:
+		var variant410 golem_agent_common.AgentError
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+			value202 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant410 = golem_agent_common.MakeAgentErrorInvalidInput(value202)
+
+		case 1:
+			value203 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant410 = golem_agent_common.MakeAgentErrorInvalidMethod(value203)
+
+		case 2:
+			value204 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant410 = golem_agent_common.MakeAgentErrorInvalidType(value204)
+
+		case 3:
+			value205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant410 = golem_agent_common.MakeAgentErrorInvalidAgentId(value205)
+
+		case 4:
+			result381 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))), index*(56+22*4))
+				var variant369 golem_core_types.SchemaTypeBody
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 1:
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+				case 2:
+					var option212 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option212 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option207 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option207 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant206 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant206 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant206 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant206 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option207 = witTypes.Some[golem_core_types.NumericBound](variant206)
+						default:
+							panic("unreachable")
+						}
+						var option209 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option209 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant208 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant208 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant208 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant208 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option209 = witTypes.Some[golem_core_types.NumericBound](variant208)
+						default:
+							panic("unreachable")
+						}
+						var option211 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option211 = witTypes.None[string]()
+						case 1:
+							value210 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option211 = witTypes.Some[string](value210)
+						default:
+							panic("unreachable")
+						}
+
+						option212 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option207, option209, option211})
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyS8Type(option212)
+
+				case 3:
+					var option219 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option219 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option214 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option214 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant213 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant213 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant213 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant213 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option214 = witTypes.Some[golem_core_types.NumericBound](variant213)
+						default:
+							panic("unreachable")
+						}
+						var option216 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option216 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant215 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant215 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant215 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant215 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option216 = witTypes.Some[golem_core_types.NumericBound](variant215)
+						default:
+							panic("unreachable")
+						}
+						var option218 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option218 = witTypes.None[string]()
+						case 1:
+							value217 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option218 = witTypes.Some[string](value217)
+						default:
+							panic("unreachable")
+						}
+
+						option219 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option214, option216, option218})
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyS16Type(option219)
+
+				case 4:
+					var option226 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option226 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option221 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option221 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant220 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant220 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant220 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant220 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option221 = witTypes.Some[golem_core_types.NumericBound](variant220)
+						default:
+							panic("unreachable")
+						}
+						var option223 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option223 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant222 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant222 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant222 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant222 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option223 = witTypes.Some[golem_core_types.NumericBound](variant222)
+						default:
+							panic("unreachable")
+						}
+						var option225 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option225 = witTypes.None[string]()
+						case 1:
+							value224 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option225 = witTypes.Some[string](value224)
+						default:
+							panic("unreachable")
+						}
+
+						option226 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option221, option223, option225})
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyS32Type(option226)
+
+				case 5:
+					var option233 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option233 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option228 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option228 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant227 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant227 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant227 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant227 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option228 = witTypes.Some[golem_core_types.NumericBound](variant227)
+						default:
+							panic("unreachable")
+						}
+						var option230 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option230 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant229 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant229 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant229 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant229 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option230 = witTypes.Some[golem_core_types.NumericBound](variant229)
+						default:
+							panic("unreachable")
+						}
+						var option232 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option232 = witTypes.None[string]()
+						case 1:
+							value231 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option232 = witTypes.Some[string](value231)
+						default:
+							panic("unreachable")
+						}
+
+						option233 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option228, option230, option232})
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyS64Type(option233)
+
+				case 6:
+					var option240 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option240 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option235 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option235 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant234 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant234 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant234 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant234 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option235 = witTypes.Some[golem_core_types.NumericBound](variant234)
+						default:
+							panic("unreachable")
+						}
+						var option237 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option237 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant236 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant236 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant236 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant236 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option237 = witTypes.Some[golem_core_types.NumericBound](variant236)
+						default:
+							panic("unreachable")
+						}
+						var option239 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option239 = witTypes.None[string]()
+						case 1:
+							value238 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option239 = witTypes.Some[string](value238)
+						default:
+							panic("unreachable")
+						}
+
+						option240 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option235, option237, option239})
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyU8Type(option240)
+
+				case 7:
+					var option247 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option247 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option242 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option242 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant241 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant241 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant241 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant241 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option242 = witTypes.Some[golem_core_types.NumericBound](variant241)
+						default:
+							panic("unreachable")
+						}
+						var option244 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option244 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant243 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant243 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant243 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant243 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option244 = witTypes.Some[golem_core_types.NumericBound](variant243)
+						default:
+							panic("unreachable")
+						}
+						var option246 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option246 = witTypes.None[string]()
+						case 1:
+							value245 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option246 = witTypes.Some[string](value245)
+						default:
+							panic("unreachable")
+						}
+
+						option247 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option242, option244, option246})
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyU16Type(option247)
+
+				case 8:
+					var option254 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option254 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option249 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option249 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant248 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant248 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant248 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant248 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option249 = witTypes.Some[golem_core_types.NumericBound](variant248)
+						default:
+							panic("unreachable")
+						}
+						var option251 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option251 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant250 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant250 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant250 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant250 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option251 = witTypes.Some[golem_core_types.NumericBound](variant250)
+						default:
+							panic("unreachable")
+						}
+						var option253 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option253 = witTypes.None[string]()
+						case 1:
+							value252 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option253 = witTypes.Some[string](value252)
+						default:
+							panic("unreachable")
+						}
+
+						option254 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option249, option251, option253})
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyU32Type(option254)
+
+				case 9:
+					var option261 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option261 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option256 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option256 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant255 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant255 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant255 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant255 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option256 = witTypes.Some[golem_core_types.NumericBound](variant255)
+						default:
+							panic("unreachable")
+						}
+						var option258 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option258 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant257 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant257 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant257 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant257 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option258 = witTypes.Some[golem_core_types.NumericBound](variant257)
+						default:
+							panic("unreachable")
+						}
+						var option260 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option260 = witTypes.None[string]()
+						case 1:
+							value259 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option260 = witTypes.Some[string](value259)
+						default:
+							panic("unreachable")
+						}
+
+						option261 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option256, option258, option260})
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyU64Type(option261)
+
+				case 10:
+					var option268 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option268 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option263 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option263 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant262 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant262 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant262 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant262 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option263 = witTypes.Some[golem_core_types.NumericBound](variant262)
+						default:
+							panic("unreachable")
+						}
+						var option265 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option265 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant264 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant264 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant264 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant264 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option265 = witTypes.Some[golem_core_types.NumericBound](variant264)
+						default:
+							panic("unreachable")
+						}
+						var option267 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option267 = witTypes.None[string]()
+						case 1:
+							value266 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option267 = witTypes.Some[string](value266)
+						default:
+							panic("unreachable")
+						}
+
+						option268 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option263, option265, option267})
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyF32Type(option268)
+
+				case 11:
+					var option275 witTypes.Option[golem_core_types.NumericRestrictions]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option275 = witTypes.None[golem_core_types.NumericRestrictions]()
+					case 1:
+						var option270 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option270 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant269 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+							case 0:
+
+								variant269 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+							case 1:
+
+								variant269 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							case 2:
+
+								variant269 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option270 = witTypes.Some[golem_core_types.NumericBound](variant269)
+						default:
+							panic("unreachable")
+						}
+						var option272 witTypes.Option[golem_core_types.NumericBound]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+						case 0:
+
+							option272 = witTypes.None[golem_core_types.NumericBound]()
+						case 1:
+							var variant271 golem_core_types.NumericBound
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+							case 0:
+
+								variant271 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+							case 1:
+
+								variant271 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							case 2:
+
+								variant271 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+							default:
+								panic("unreachable")
+							}
+
+							option272 = witTypes.Some[golem_core_types.NumericBound](variant271)
+						default:
+							panic("unreachable")
+						}
+						var option274 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+						case 0:
+
+							option274 = witTypes.None[string]()
+						case 1:
+							value273 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+							option274 = witTypes.Some[string](value273)
+						default:
+							panic("unreachable")
+						}
+
+						option275 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option270, option272, option274})
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyF64Type(option275)
+
+				case 12:
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+				case 13:
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+				case 14:
+					result288 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+						value276 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option278 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+						case 0:
+
+							option278 = witTypes.None[string]()
+						case 1:
+							value277 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							option278 = witTypes.Some[string](value277)
+						default:
+							panic("unreachable")
+						}
+						result280 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+							value279 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result280 = append(result280, value279)
+						}
+
+						result282 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+							value281 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result282 = append(result282, value281)
+						}
+
+						var option284 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+						case 0:
+
+							option284 = witTypes.None[string]()
+						case 1:
+							value283 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+							option284 = witTypes.Some[string](value283)
+						default:
+							panic("unreachable")
+						}
+						var option287 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+						case 0:
+
+							option287 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant286 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+							case 0:
+
+								variant286 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant286 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant286 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value285 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+								variant286 = golem_core_types.MakeRoleOther(value285)
+
+							default:
+								panic("unreachable")
+							}
+
+							option287 = witTypes.Some[golem_core_types.Role](variant286)
+						default:
+							panic("unreachable")
+						}
+
+						result288 = append(result288, golem_core_types.NamedFieldType{value276, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option278, result280, result282, option284, option287}})
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyRecordType(result288)
+
+				case 15:
+					result302 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+						value289 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option290 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option290 = witTypes.None[int32]()
+						case 1:
+
+							option290 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+						default:
+							panic("unreachable")
+						}
+						var option292 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option292 = witTypes.None[string]()
+						case 1:
+							value291 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option292 = witTypes.Some[string](value291)
+						default:
+							panic("unreachable")
+						}
+						result294 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+							value293 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result294 = append(result294, value293)
+						}
+
+						result296 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+							value295 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result296 = append(result296, value295)
+						}
+
+						var option298 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+						case 0:
+
+							option298 = witTypes.None[string]()
+						case 1:
+							value297 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+							option298 = witTypes.Some[string](value297)
+						default:
+							panic("unreachable")
+						}
+						var option301 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+						case 0:
+
+							option301 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant300 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+							case 0:
+
+								variant300 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant300 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant300 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value299 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+								variant300 = golem_core_types.MakeRoleOther(value299)
+
+							default:
+								panic("unreachable")
+							}
+
+							option301 = witTypes.Some[golem_core_types.Role](variant300)
+						default:
+							panic("unreachable")
+						}
+
+						result302 = append(result302, golem_core_types.VariantCaseType{value289, option290, golem_core_types.MetadataEnvelope{option292, result294, result296, option298, option301}})
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyVariantType(result302)
+
+				case 16:
+					result304 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+						value303 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result304 = append(result304, value303)
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyEnumType(result304)
+
+				case 17:
+					result306 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+						value305 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result306 = append(result306, value305)
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyFlagsType(result306)
+
+				case 18:
+					result307 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result307 = append(result307, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyTupleType(result307)
+
+				case 19:
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 20:
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+				case 21:
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+				case 22:
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 23:
+					var option308 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option308 = witTypes.None[int32]()
+					case 1:
+
+						option308 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+					var option309 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						option309 = witTypes.None[int32]()
+					case 1:
+
+						option309 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option308, option309})
+
+				case 24:
+					var option312 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option312 = witTypes.None[[]string]()
+					case 1:
+						result311 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+							value310 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result311 = append(result311, value310)
+						}
+
+						option312 = witTypes.Some[[]string](result311)
+					default:
+						panic("unreachable")
+					}
+					var option313 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+					case 0:
+
+						option313 = witTypes.None[uint32]()
+					case 1:
+
+						option313 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+					var option314 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+					case 0:
+
+						option314 = witTypes.None[uint32]()
+					case 1:
+
+						option314 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+					var option316 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+					case 0:
+
+						option316 = witTypes.None[string]()
+					case 1:
+						value315 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+						option316 = witTypes.Some[string](value315)
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option312, option313, option314, option316})
+
+				case 25:
+					var option319 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option319 = witTypes.None[[]string]()
+					case 1:
+						result318 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+							value317 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result318 = append(result318, value317)
+						}
+
+						option319 = witTypes.Some[[]string](result318)
+					default:
+						panic("unreachable")
+					}
+					var option320 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+					case 0:
+
+						option320 = witTypes.None[uint32]()
+					case 1:
+
+						option320 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+					var option321 witTypes.Option[uint32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+					case 0:
+
+						option321 = witTypes.None[uint32]()
+					case 1:
+
+						option321 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option319, option320, option321})
+
+				case 26:
+					var option324 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+					case 0:
+
+						option324 = witTypes.None[[]string]()
+					case 1:
+						result323 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+							value322 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result323 = append(result323, value322)
+						}
+
+						option324 = witTypes.Some[[]string](result323)
+					default:
+						panic("unreachable")
+					}
+					var option327 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+					case 0:
+
+						option327 = witTypes.None[[]string]()
+					case 1:
+						result326 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+							value325 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result326 = append(result326, value325)
+						}
+
+						option327 = witTypes.Some[[]string](result326)
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option324, option327})
+
+				case 27:
+					var option330 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option330 = witTypes.None[[]string]()
+					case 1:
+						result329 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+							value328 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result329 = append(result329, value328)
+						}
+
+						option330 = witTypes.Some[[]string](result329)
+					default:
+						panic("unreachable")
+					}
+					var option333 witTypes.Option[[]string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+					case 0:
+
+						option333 = witTypes.None[[]string]()
+					case 1:
+						result332 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+							value331 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result332 = append(result332, value331)
+						}
+
+						option333 = witTypes.Some[[]string](result332)
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option330, option333})
+
+				case 28:
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+				case 29:
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+				case 30:
+					value334 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					result336 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+						value335 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result336 = append(result336, value335)
+					}
+
+					var option338 witTypes.Option[golem_core_types.QuantityValue]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+					case 0:
+
+						option338 = witTypes.None[golem_core_types.QuantityValue]()
+					case 1:
+						value337 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+						option338 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value337})
+					default:
+						panic("unreachable")
+					}
+					var option340 witTypes.Option[golem_core_types.QuantityValue]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+					case 0:
+
+						option340 = witTypes.None[golem_core_types.QuantityValue]()
+					case 1:
+						value339 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+						option340 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value339})
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value334, result336, option338, option340})
+
+				case 31:
+					result362 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+						value341 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var variant350 golem_core_types.DiscriminatorRule
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+						case 0:
+							value342 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant350 = golem_core_types.MakeDiscriminatorRulePrefix(value342)
+
+						case 1:
+							value343 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant350 = golem_core_types.MakeDiscriminatorRuleSuffix(value343)
+
+						case 2:
+							value344 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant350 = golem_core_types.MakeDiscriminatorRuleContains(value344)
+
+						case 3:
+							value345 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant350 = golem_core_types.MakeDiscriminatorRuleRegex(value345)
+
+						case 4:
+							value346 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+							var option348 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+							case 0:
+
+								option348 = witTypes.None[string]()
+							case 1:
+								value347 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+								option348 = witTypes.Some[string](value347)
+							default:
+								panic("unreachable")
+							}
+
+							variant350 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value346, option348})
+
+						case 5:
+							value349 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+							variant350 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value349)
+
+						default:
+							panic("unreachable")
+						}
+						var option352 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+						case 0:
+
+							option352 = witTypes.None[string]()
+						case 1:
+							value351 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+							option352 = witTypes.Some[string](value351)
+						default:
+							panic("unreachable")
+						}
+						result354 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+							value353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result354 = append(result354, value353)
+						}
+
+						result356 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+							value355 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result356 = append(result356, value355)
+						}
+
+						var option358 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+						case 0:
+
+							option358 = witTypes.None[string]()
+						case 1:
+							value357 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+							option358 = witTypes.Some[string](value357)
+						default:
+							panic("unreachable")
+						}
+						var option361 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+						case 0:
+
+							option361 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant360 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+							case 0:
+
+								variant360 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant360 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant360 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value359 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+								variant360 = golem_core_types.MakeRoleOther(value359)
+
+							default:
+								panic("unreachable")
+							}
+
+							option361 = witTypes.Some[golem_core_types.Role](variant360)
+						default:
+							panic("unreachable")
+						}
+
+						result362 = append(result362, golem_core_types.UnionBranch{value341, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant350, golem_core_types.MetadataEnvelope{option352, result354, result356, option358, option361}})
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result362})
+
+				case 32:
+					var option364 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+					case 0:
+
+						option364 = witTypes.None[string]()
+					case 1:
+						value363 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						option364 = witTypes.Some[string](value363)
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option364})
+
+				case 33:
+					var option366 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option366 = witTypes.None[string]()
+					case 1:
+						value365 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+						option366 = witTypes.Some[string](value365)
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option366})
+
+				case 34:
+					var option367 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option367 = witTypes.None[int32]()
+					case 1:
+
+						option367 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyFutureType(option367)
+
+				case 35:
+					var option368 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option368 = witTypes.None[int32]()
+					case 1:
+
+						option368 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+
+					variant369 = golem_core_types.MakeSchemaTypeBodyStreamType(option368)
+
+				default:
+					panic("unreachable")
+				}
+				var option371 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+				case 0:
+
+					option371 = witTypes.None[string]()
+				case 1:
+					value370 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+					option371 = witTypes.Some[string](value370)
+				default:
+					panic("unreachable")
+				}
+				result373 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+					value372 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result373 = append(result373, value372)
+				}
+
+				result375 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+					value374 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result375 = append(result375, value374)
+				}
+
+				var option377 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+				case 0:
+
+					option377 = witTypes.None[string]()
+				case 1:
+					value376 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+					option377 = witTypes.Some[string](value376)
+				default:
+					panic("unreachable")
+				}
+				var option380 witTypes.Option[golem_core_types.Role]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+				case 0:
+
+					option380 = witTypes.None[golem_core_types.Role]()
+				case 1:
+					var variant379 golem_core_types.Role
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+					case 0:
+
+						variant379 = golem_core_types.MakeRoleMultimodal()
+
+					case 1:
+
+						variant379 = golem_core_types.MakeRoleUnstructuredText()
+
+					case 2:
+
+						variant379 = golem_core_types.MakeRoleUnstructuredBinary()
+
+					case 3:
+						value378 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+						variant379 = golem_core_types.MakeRoleOther(value378)
+
+					default:
+						panic("unreachable")
+					}
+
+					option380 = witTypes.Some[golem_core_types.Role](variant379)
+				default:
+					panic("unreachable")
+				}
+
+				result381 = append(result381, golem_core_types.SchemaTypeNode{variant369, golem_core_types.MetadataEnvelope{option371, result373, result375, option377, option380}})
+			}
+
+			result385 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 4*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 4*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4))))), index*(6*4))
+				value382 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+				var option384 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+				case 0:
+
+					option384 = witTypes.None[string]()
+				case 1:
+					value383 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+					option384 = witTypes.Some[string](value383)
+				default:
+					panic("unreachable")
+				}
+
+				result385 = append(result385, golem_core_types.SchemaTypeDef{value382, option384, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+			}
+
+			result409 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 7*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 7*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 6*4))))), index*(16+4*4))
+				var variant408 golem_core_types.SchemaValueNode
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+				case 1:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 2:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 3:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 4:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 5:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 6:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 7:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 8:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 9:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 10:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 11:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 12:
+					value386 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant408 = golem_core_types.MakeSchemaValueNodeStringValue(value386)
+
+				case 13:
+					result387 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result387 = append(result387, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant408 = golem_core_types.MakeSchemaValueNodeRecordValue(result387)
+
+				case 14:
+					var option388 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+					case 0:
+
+						option388 = witTypes.None[int32]()
+					case 1:
+
+						option388 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+					default:
+						panic("unreachable")
+					}
+
+					variant408 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option388})
+
+				case 15:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 16:
+					result389 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+						result389 = append(result389, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+					}
+
+					variant408 = golem_core_types.MakeSchemaValueNodeFlagsValue(result389)
+
+				case 17:
+					result390 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result390 = append(result390, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant408 = golem_core_types.MakeSchemaValueNodeTupleValue(result390)
+
+				case 18:
+					result391 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result391 = append(result391, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant408 = golem_core_types.MakeSchemaValueNodeListValue(result391)
+
+				case 19:
+					result392 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result392 = append(result392, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant408 = golem_core_types.MakeSchemaValueNodeFixedListValue(result392)
+
+				case 20:
+					result393 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+						result393 = append(result393, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+					}
+
+					variant408 = golem_core_types.MakeSchemaValueNodeMapValue(result393)
+
+				case 21:
+					var option394 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option394 = witTypes.None[int32]()
+					case 1:
+
+						option394 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+
+					variant408 = golem_core_types.MakeSchemaValueNodeOptionValue(option394)
+
+				case 22:
+					var variant397 golem_core_types.ResultValuePayload
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+						var option395 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+						case 0:
+
+							option395 = witTypes.None[int32]()
+						case 1:
+
+							option395 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+						default:
+							panic("unreachable")
+						}
+
+						variant397 = golem_core_types.MakeResultValuePayloadOkValue(option395)
+
+					case 1:
+						var option396 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+						case 0:
+
+							option396 = witTypes.None[int32]()
+						case 1:
+
+							option396 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+						default:
+							panic("unreachable")
+						}
+
+						variant397 = golem_core_types.MakeResultValuePayloadErrValue(option396)
+
+					default:
+						panic("unreachable")
+					}
+
+					variant408 = golem_core_types.MakeSchemaValueNodeResultValue(variant397)
+
+				case 23:
+					value398 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					var option400 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						option400 = witTypes.None[string]()
+					case 1:
+						value399 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+						option400 = witTypes.Some[string](value399)
+					default:
+						panic("unreachable")
+					}
+
+					variant408 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value398, option400})
+
+				case 24:
+					value401 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					var option403 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						option403 = witTypes.None[string]()
+					case 1:
+						value402 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+						option403 = witTypes.Some[string](value402)
+					default:
+						panic("unreachable")
+					}
+
+					variant408 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value401, option403})
+
+				case 25:
+					value404 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant408 = golem_core_types.MakeSchemaValueNodePathValue(value404)
+
+				case 26:
+					value405 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant408 = golem_core_types.MakeSchemaValueNodeUrlValue(value405)
+
+				case 27:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+				case 28:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+				case 29:
+					value406 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+					variant408 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value406})
+
+				case 30:
+					value407 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant408 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value407, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+				case 31:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+				case 32:
+
+					variant408 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+				default:
+					panic("unreachable")
+				}
+
+				result409 = append(result409, variant408)
+			}
+
+			variant410 = golem_agent_common.MakeAgentErrorCustomError(golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result381, result385, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 5*4)))}, golem_core_types.SchemaValueTree{result409, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 8*4)))}})
+
+		default:
+			panic("unreachable")
+		}
+
+		result411 = witTypes.Err[witTypes.Tuple3[string, golem_core_types.TypedSchemaValue, witTypes.Option[golem_core_types.Uuid]], golem_agent_common.AgentError](variant410)
+	default:
+		panic("unreachable")
+	}
+	result412 := result411
+	return result412
+
+}
+
+//go:wasmimport golem:agent/host@2.0.0 create-webhook
+func wasm_import_create_webhook(arg0 int64, arg1 int64, arg2 uintptr, arg3 uint32, arg4 int64, arg5 uintptr)
+
+func CreateWebhook(promiseId golem_core_types.PromiseId) string {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(((promiseId).AgentId).AgentId))
+	pinner.Pin(utf8)
+	wasm_import_create_webhook(int64(((((promiseId).AgentId).ComponentId).Uuid).HighBits), int64(((((promiseId).AgentId).ComponentId).Uuid).LowBits), uintptr(utf8), uint32(len(((promiseId).AgentId).AgentId)), int64((promiseId).OplogIdx), returnArea)
+	value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	result := value
+	return result
+
+}
+
+//go:wasmimport golem:agent/host@2.0.0 [constructor]wasm-rpc
+func wasm_import_constructor_wasm_rpc(arg0 uintptr, arg1 uint32, arg2 uintptr, arg3 uint32, arg4 int32, arg5 int32, arg6 int64, arg7 int64, arg8 uintptr, arg9 uint32) int32
+
+func MakeWasmRpc(agentTypeName string, constructor golem_core_types.SchemaValueTree, phantomId witTypes.Option[golem_core_types.Uuid], agentConfig []golem_agent_common.TypedAgentConfigValue) *WasmRpc {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData(agentTypeName))
+	pinner.Pin(utf8)
+	slice25 := (constructor).ValueNodes
+	length27 := uint32(len(slice25))
+	result26 := witRuntime.Allocate(pinner, uintptr(length27*(16+4*4)), 8)
+	for index, element := range slice25 {
+		base := unsafe.Add(result26, index*(16+4*4))
+
+		switch element.Tag() {
+		case golem_core_types.SchemaValueNodeBoolValue:
+			payload := element.BoolValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case golem_core_types.SchemaValueNodeS8Value:
+			payload := element.S8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS16Value:
+			payload := element.S16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS32Value:
+			payload := element.S32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeS64Value:
+			payload := element.S64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeU8Value:
+			payload := element.U8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU16Value:
+			payload := element.U16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU32Value:
+			payload := element.U32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeU64Value:
+			payload := element.U64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case golem_core_types.SchemaValueNodeF32Value:
+			payload := element.F32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeF64Value:
+			payload := element.F64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeCharValue:
+			payload := element.CharValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeStringValue:
+			payload := element.StringValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case golem_core_types.SchemaValueNodeRecordValue:
+			payload := element.RecordValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			slice := payload
+			length := uint32(len(slice))
+			result1 := witRuntime.Allocate(pinner, uintptr(length*4), 4)
+			for index, element := range slice {
+				base := unsafe.Add(result1, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result1)))
+
+		case golem_core_types.SchemaValueNodeVariantValue:
+			payload := element.VariantValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).Case)
+
+			switch (payload).Payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeEnumValue:
+			payload := element.EnumValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeFlagsValue:
+			payload := element.FlagsValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			slice3 := payload
+			length5 := uint32(len(slice3))
+			result4 := witRuntime.Allocate(pinner, uintptr(length5*1), 1)
+			for index, element := range slice3 {
+				base := unsafe.Add(result4, index*1)
+				var result2 int32
+				if element {
+					result2 = 1
+				} else {
+					result2 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result2)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length5)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result4)))
+
+		case golem_core_types.SchemaValueNodeTupleValue:
+			payload := element.TupleValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			slice6 := payload
+			length8 := uint32(len(slice6))
+			result7 := witRuntime.Allocate(pinner, uintptr(length8*4), 4)
+			for index, element := range slice6 {
+				base := unsafe.Add(result7, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length8)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result7)))
+
+		case golem_core_types.SchemaValueNodeListValue:
+			payload := element.ListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			slice9 := payload
+			length11 := uint32(len(slice9))
+			result10 := witRuntime.Allocate(pinner, uintptr(length11*4), 4)
+			for index, element := range slice9 {
+				base := unsafe.Add(result10, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length11)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result10)))
+
+		case golem_core_types.SchemaValueNodeFixedListValue:
+			payload := element.FixedListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			slice12 := payload
+			length14 := uint32(len(slice12))
+			result13 := witRuntime.Allocate(pinner, uintptr(length14*4), 4)
+			for index, element := range slice12 {
+				base := unsafe.Add(result13, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length14)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result13)))
+
+		case golem_core_types.SchemaValueNodeMapValue:
+			payload := element.MapValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			slice15 := payload
+			length17 := uint32(len(slice15))
+			result16 := witRuntime.Allocate(pinner, uintptr(length17*8), 4)
+			for index, element := range slice15 {
+				base := unsafe.Add(result16, index*8)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).Key
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (element).Value
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length17)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result16)))
+
+		case golem_core_types.SchemaValueNodeOptionValue:
+			payload := element.OptionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeResultValue:
+			payload := element.ResultValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+
+			switch payload.Tag() {
+			case golem_core_types.ResultValuePayloadOkValue:
+				payload := payload.OkValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.ResultValuePayloadErrValue:
+				payload := payload.ErrValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeTextValue:
+			payload := element.TextValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+			utf818 := unsafe.Pointer(unsafe.StringData((payload).Text))
+			pinner.Pin(utf818)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf818)))
+
+			switch (payload).Language.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Language.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf819 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf819)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf819)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeBinaryValue:
+			payload := element.BinaryValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+			data := unsafe.Pointer(unsafe.SliceData((payload).Bytes))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+			switch (payload).MimeType.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MimeType.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf820 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf820)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf820)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodePathValue:
+			payload := element.PathValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			utf821 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf821)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf821)))
+
+		case golem_core_types.SchemaValueNodeUrlValue:
+			payload := element.UrlValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			utf822 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf822)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf822)))
+
+		case golem_core_types.SchemaValueNodeDatetimeValue:
+			payload := element.DatetimeValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = int32((payload).Nanoseconds)
+
+		case golem_core_types.SchemaValueNodeDurationValue:
+			payload := element.DurationValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Nanoseconds
+
+		case golem_core_types.SchemaValueNodeQuantityValueNode:
+			payload := element.QuantityValueNode()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Mantissa
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Scale
+			utf823 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+			pinner.Pin(utf823)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uint32(len((payload).Unit)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))) = uint32(uintptr(uintptr(utf823)))
+
+		case golem_core_types.SchemaValueNodeUnionValue:
+			payload := element.UnionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			utf824 := unsafe.Pointer(unsafe.StringData((payload).Tag))
+			pinner.Pin(utf824)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf824)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Body
+
+		case golem_core_types.SchemaValueNodeSecretValue:
+			payload := element.SecretValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		case golem_core_types.SchemaValueNodeQuotaTokenHandle:
+			payload := element.QuotaTokenHandle()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	var option int32
+	var option28 int64
+	var option29 int64
+	switch phantomId.Tag() {
+	case witTypes.OptionNone:
+
+		option = int32(0)
+		option28 = 0
+		option29 = 0
+	case witTypes.OptionSome:
+		payload := phantomId.Some()
+
+		option = int32(1)
+		option28 = int64((payload).HighBits)
+		option29 = int64((payload).LowBits)
+	default:
+		panic("unreachable")
+	}
+	slice192 := agentConfig
+	length194 := uint32(len(slice192))
+	result193 := witRuntime.Allocate(pinner, uintptr(length194*(10*4)), 4)
+	for index, element := range slice192 {
+		base := unsafe.Add(result193, index*(10*4))
+		slice31 := (element).Path
+		length33 := uint32(len(slice31))
+		result32 := witRuntime.Allocate(pinner, uintptr(length33*(2*4)), 4)
+		for index, element := range slice31 {
+			base := unsafe.Add(result32, index*(2*4))
+			utf830 := unsafe.Pointer(unsafe.StringData(element))
+			pinner.Pin(utf830)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf830)))
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(length33)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(result32)))
+		slice152 := (((element).Value).Graph).TypeNodes
+		length154 := uint32(len(slice152))
+		result153 := witRuntime.Allocate(pinner, uintptr(length154*(56+22*4)), 8)
+		for index, element := range slice152 {
+			base := unsafe.Add(result153, index*(56+22*4))
+
+			switch (element).Body.Tag() {
+			case golem_core_types.SchemaTypeBodyRefType:
+				payload := (element).Body.RefType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+			case golem_core_types.SchemaTypeBodyBoolType:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+			case golem_core_types.SchemaTypeBodyS8Type:
+				payload := (element).Body.S8Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf834 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf834)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf834)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyS16Type:
+				payload := (element).Body.S16Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf835 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf835)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf835)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyS32Type:
+				payload := (element).Body.S32Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf836 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf836)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf836)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyS64Type:
+				payload := (element).Body.S64Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf837 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf837)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf837)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyU8Type:
+				payload := (element).Body.U8Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf838 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf838)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf838)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyU16Type:
+				payload := (element).Body.U16Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf839 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf839)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf839)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyU32Type:
+				payload := (element).Body.U32Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf840 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf840)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf840)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyU64Type:
+				payload := (element).Body.U64Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf841 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf841)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf841)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyF32Type:
+				payload := (element).Body.F32Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf842 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf842)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf842)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyF64Type:
+				payload := (element).Body.F64Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf843 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf843)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf843)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyCharType:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+
+			case golem_core_types.SchemaTypeBodyStringType:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+
+			case golem_core_types.SchemaTypeBodyRecordType:
+				payload := (element).Body.RecordType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+				slice56 := payload
+				length58 := uint32(len(slice56))
+				result57 := witRuntime.Allocate(pinner, uintptr(length58*(17*4)), 4)
+				for index, element := range slice56 {
+					base := unsafe.Add(result57, index*(17*4))
+					utf844 := unsafe.Pointer(unsafe.StringData((element).Name))
+					pinner.Pin(utf844)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf844)))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+					switch ((element).Metadata).Doc.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Doc.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+						utf845 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf845)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf845)))
+
+					default:
+						panic("unreachable")
+					}
+					slice47 := ((element).Metadata).Aliases
+					length49 := uint32(len(slice47))
+					result48 := witRuntime.Allocate(pinner, uintptr(length49*(2*4)), 4)
+					for index, element := range slice47 {
+						base := unsafe.Add(result48, index*(2*4))
+						utf846 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf846)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf846)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length49)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result48)))
+					slice51 := ((element).Metadata).Examples
+					length53 := uint32(len(slice51))
+					result52 := witRuntime.Allocate(pinner, uintptr(length53*(2*4)), 4)
+					for index, element := range slice51 {
+						base := unsafe.Add(result52, index*(2*4))
+						utf850 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf850)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf850)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = uint32(length53)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result52)))
+
+					switch ((element).Metadata).Deprecated.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Deprecated.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(1))
+						utf854 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf854)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf854)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Role.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Role.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.RoleMultimodal:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(0))
+
+						case golem_core_types.RoleUnstructuredText:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(1))
+
+						case golem_core_types.RoleUnstructuredBinary:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(2))
+
+						case golem_core_types.RoleOther:
+							payload := payload.Other()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(3))
+							utf855 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf855)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uintptr(uintptr(utf855)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length58)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result57)))
+
+			case golem_core_types.SchemaTypeBodyVariantType:
+				payload := (element).Body.VariantType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+				slice71 := payload
+				length73 := uint32(len(slice71))
+				result72 := witRuntime.Allocate(pinner, uintptr(length73*(8+16*4)), 4)
+				for index, element := range slice71 {
+					base := unsafe.Add(result72, index*(8+16*4))
+					utf859 := unsafe.Pointer(unsafe.StringData((element).Name))
+					pinner.Pin(utf859)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf859)))
+
+					switch (element).Payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (element).Payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = payload
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Doc.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Doc.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						utf860 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf860)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf860)))
+
+					default:
+						panic("unreachable")
+					}
+					slice62 := ((element).Metadata).Aliases
+					length64 := uint32(len(slice62))
+					result63 := witRuntime.Allocate(pinner, uintptr(length64*(2*4)), 4)
+					for index, element := range slice62 {
+						base := unsafe.Add(result63, index*(2*4))
+						utf861 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf861)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf861)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length64)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result63)))
+					slice66 := ((element).Metadata).Examples
+					length68 := uint32(len(slice66))
+					result67 := witRuntime.Allocate(pinner, uintptr(length68*(2*4)), 4)
+					for index, element := range slice66 {
+						base := unsafe.Add(result67, index*(2*4))
+						utf865 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf865)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf865)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length68)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result67)))
+
+					switch ((element).Metadata).Deprecated.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Deprecated.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+						utf869 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf869)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf869)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Role.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Role.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.RoleMultimodal:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+						case golem_core_types.RoleUnstructuredText:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+						case golem_core_types.RoleUnstructuredBinary:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+						case golem_core_types.RoleOther:
+							payload := payload.Other()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+							utf870 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf870)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf870)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length73)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result72)))
+
+			case golem_core_types.SchemaTypeBodyEnumType:
+				payload := (element).Body.EnumType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+				slice75 := payload
+				length77 := uint32(len(slice75))
+				result76 := witRuntime.Allocate(pinner, uintptr(length77*(2*4)), 4)
+				for index, element := range slice75 {
+					base := unsafe.Add(result76, index*(2*4))
+					utf874 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf874)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf874)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length77)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result76)))
+
+			case golem_core_types.SchemaTypeBodyFlagsType:
+				payload := (element).Body.FlagsType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+				slice79 := payload
+				length81 := uint32(len(slice79))
+				result80 := witRuntime.Allocate(pinner, uintptr(length81*(2*4)), 4)
+				for index, element := range slice79 {
+					base := unsafe.Add(result80, index*(2*4))
+					utf878 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf878)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf878)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length81)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result80)))
+
+			case golem_core_types.SchemaTypeBodyTupleType:
+				payload := (element).Body.TupleType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+				slice82 := payload
+				length84 := uint32(len(slice82))
+				result83 := witRuntime.Allocate(pinner, uintptr(length84*4), 4)
+				for index, element := range slice82 {
+					base := unsafe.Add(result83, index*4)
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length84)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result83)))
+
+			case golem_core_types.SchemaTypeBodyListType:
+				payload := (element).Body.ListType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+			case golem_core_types.SchemaTypeBodyFixedListType:
+				payload := (element).Body.FixedListType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Element
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Length)
+
+			case golem_core_types.SchemaTypeBodyMapType:
+				payload := (element).Body.MapType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Key
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Value
+
+			case golem_core_types.SchemaTypeBodyOptionType:
+				payload := (element).Body.OptionType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+			case golem_core_types.SchemaTypeBodyResultType:
+				payload := (element).Body.ResultType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+				switch (payload).Ok.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Ok.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Err.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Err.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyTextType:
+				payload := (element).Body.TextType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+				switch (payload).Languages.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Languages.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+					slice86 := payload
+					length88 := uint32(len(slice86))
+					result87 := witRuntime.Allocate(pinner, uintptr(length88*(2*4)), 4)
+					for index, element := range slice86 {
+						base := unsafe.Add(result87, index*(2*4))
+						utf885 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf885)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf885)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length88)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result87)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).MinLength.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).MinLength.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).MaxLength.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).MaxLength.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Regex.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Regex.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(1))
+					utf889 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf889)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = uint32(uintptr(uintptr(utf889)))
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyBinaryType:
+				payload := (element).Body.BinaryType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+
+				switch (payload).MimeTypes.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).MimeTypes.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+					slice91 := payload
+					length93 := uint32(len(slice91))
+					result92 := witRuntime.Allocate(pinner, uintptr(length93*(2*4)), 4)
+					for index, element := range slice91 {
+						base := unsafe.Add(result92, index*(2*4))
+						utf890 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf890)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf890)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length93)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result92)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).MinBytes.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).MinBytes.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).MaxBytes.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).MaxBytes.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyPathType:
+				payload := (element).Body.PathType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Direction))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Kind))
+
+				switch (payload).AllowedMimeTypes.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).AllowedMimeTypes.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+					slice95 := payload
+					length97 := uint32(len(slice95))
+					result96 := witRuntime.Allocate(pinner, uintptr(length97*(2*4)), 4)
+					for index, element := range slice95 {
+						base := unsafe.Add(result96, index*(2*4))
+						utf894 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf894)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf894)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length97)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result96)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).AllowedExtensions.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).AllowedExtensions.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+					slice99 := payload
+					length101 := uint32(len(slice99))
+					result100 := witRuntime.Allocate(pinner, uintptr(length101*(2*4)), 4)
+					for index, element := range slice99 {
+						base := unsafe.Add(result100, index*(2*4))
+						utf898 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf898)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf898)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length101)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result100)))
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyUrlType:
+				payload := (element).Body.UrlType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+
+				switch (payload).AllowedSchemes.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).AllowedSchemes.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+					slice103 := payload
+					length105 := uint32(len(slice103))
+					result104 := witRuntime.Allocate(pinner, uintptr(length105*(2*4)), 4)
+					for index, element := range slice103 {
+						base := unsafe.Add(result104, index*(2*4))
+						utf8102 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8102)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8102)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length105)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result104)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).AllowedHosts.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).AllowedHosts.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+					slice107 := payload
+					length109 := uint32(len(slice107))
+					result108 := witRuntime.Allocate(pinner, uintptr(length109*(2*4)), 4)
+					for index, element := range slice107 {
+						base := unsafe.Add(result108, index*(2*4))
+						utf8106 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8106)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8106)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(length109)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(result108)))
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyDatetimeType:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+			case golem_core_types.SchemaTypeBodyDurationType:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+			case golem_core_types.SchemaTypeBodyQuantityType:
+				payload := (element).Body.QuantityType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+				utf8110 := unsafe.Pointer(unsafe.StringData((payload).BaseUnit))
+				pinner.Pin(utf8110)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).BaseUnit)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8110)))
+				slice112 := (payload).AllowedSuffixes
+				length114 := uint32(len(slice112))
+				result113 := witRuntime.Allocate(pinner, uintptr(length114*(2*4)), 4)
+				for index, element := range slice112 {
+					base := unsafe.Add(result113, index*(2*4))
+					utf8111 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8111)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8111)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length114)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result113)))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))) = (payload).Mantissa
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = (payload).Scale
+					utf8115 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+					pinner.Pin(utf8115)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))) = uint32(uint32(len((payload).Unit)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uintptr(uintptr(utf8115)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(1))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))) = (payload).Mantissa
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))) = (payload).Scale
+					utf8116 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+					pinner.Pin(utf8116)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))) = uint32(uint32(len((payload).Unit)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4))) = uint32(uintptr(uintptr(utf8116)))
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyUnionType:
+				payload := (element).Body.UnionType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+				slice136 := (payload).Branches
+				length138 := uint32(len(slice136))
+				result137 := witRuntime.Allocate(pinner, uintptr(length138*(23*4)), 4)
+				for index, element := range slice136 {
+					base := unsafe.Add(result137, index*(23*4))
+					utf8117 := unsafe.Pointer(unsafe.StringData((element).Tag))
+					pinner.Pin(utf8117)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Tag)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8117)))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+					switch (element).Discriminator.Tag() {
+					case golem_core_types.DiscriminatorRulePrefix:
+						payload := (element).Discriminator.Prefix()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+						utf8118 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8118)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8118)))
+
+					case golem_core_types.DiscriminatorRuleSuffix:
+						payload := (element).Discriminator.Suffix()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+						utf8119 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8119)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8119)))
+
+					case golem_core_types.DiscriminatorRuleContains:
+						payload := (element).Discriminator.Contains()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(2))
+						utf8120 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8120)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8120)))
+
+					case golem_core_types.DiscriminatorRuleRegex:
+						payload := (element).Discriminator.Regex()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(3))
+						utf8121 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8121)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8121)))
+
+					case golem_core_types.DiscriminatorRuleFieldEquals:
+						payload := (element).Discriminator.FieldEquals()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(4))
+						utf8122 := unsafe.Pointer(unsafe.StringData((payload).FieldName))
+						pinner.Pin(utf8122)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((payload).FieldName)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8122)))
+
+						switch (payload).Literal.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Literal.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+							utf8123 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8123)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8123)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.DiscriminatorRuleFieldAbsent:
+						payload := (element).Discriminator.FieldAbsent()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(5))
+						utf8124 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8124)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8124)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Doc.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Doc.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+						utf8125 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8125)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(utf8125)))
+
+					default:
+						panic("unreachable")
+					}
+					slice127 := ((element).Metadata).Aliases
+					length129 := uint32(len(slice127))
+					result128 := witRuntime.Allocate(pinner, uintptr(length129*(2*4)), 4)
+					for index, element := range slice127 {
+						base := unsafe.Add(result128, index*(2*4))
+						utf8126 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8126)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8126)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(length129)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(result128)))
+					slice131 := ((element).Metadata).Examples
+					length133 := uint32(len(slice131))
+					result132 := witRuntime.Allocate(pinner, uintptr(length133*(2*4)), 4)
+					for index, element := range slice131 {
+						base := unsafe.Add(result132, index*(2*4))
+						utf8130 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8130)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8130)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(length133)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(result132)))
+
+					switch ((element).Metadata).Deprecated.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Deprecated.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(1))
+						utf8134 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8134)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf8134)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Role.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Role.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.RoleMultimodal:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(0))
+
+						case golem_core_types.RoleUnstructuredText:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(1))
+
+						case golem_core_types.RoleUnstructuredBinary:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(2))
+
+						case golem_core_types.RoleOther:
+							payload := payload.Other()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(3))
+							utf8135 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8135)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(utf8135)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length138)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result137)))
+
+			case golem_core_types.SchemaTypeBodySecretType:
+				payload := (element).Body.SecretType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Inner
+
+				switch (payload).Category.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Category.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+					utf8139 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8139)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8139)))
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyQuotaTokenType:
+				payload := (element).Body.QuotaTokenType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+				switch (payload).ResourceName.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).ResourceName.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+					utf8140 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8140)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf8140)))
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyFutureType:
+				payload := (element).Body.FutureType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyStreamType:
+				payload := (element).Body.StreamType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+			switch ((element).Metadata).Doc.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := ((element).Metadata).Doc.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(1))
+				utf8141 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8141)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4))) = uint32(uintptr(uintptr(utf8141)))
+
+			default:
+				panic("unreachable")
+			}
+			slice143 := ((element).Metadata).Aliases
+			length145 := uint32(len(slice143))
+			result144 := witRuntime.Allocate(pinner, uintptr(length145*(2*4)), 4)
+			for index, element := range slice143 {
+				base := unsafe.Add(result144, index*(2*4))
+				utf8142 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf8142)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8142)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length145)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result144)))
+			slice147 := ((element).Metadata).Examples
+			length149 := uint32(len(slice147))
+			result148 := witRuntime.Allocate(pinner, uintptr(length149*(2*4)), 4)
+			for index, element := range slice147 {
+				base := unsafe.Add(result148, index*(2*4))
+				utf8146 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf8146)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8146)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length149)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result148)))
+
+			switch ((element).Metadata).Deprecated.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := ((element).Metadata).Deprecated.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(1))
+				utf8150 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8150)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4))) = uint32(uintptr(uintptr(utf8150)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch ((element).Metadata).Role.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := ((element).Metadata).Role.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(1))
+
+				switch payload.Tag() {
+				case golem_core_types.RoleMultimodal:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(0))
+
+				case golem_core_types.RoleUnstructuredText:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(1))
+
+				case golem_core_types.RoleUnstructuredBinary:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(2))
+
+				case golem_core_types.RoleOther:
+					payload := payload.Other()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(3))
+					utf8151 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8151)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4))) = uint32(uintptr(uintptr(utf8151)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(length154)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(result153)))
+		slice157 := (((element).Value).Graph).Defs
+		length159 := uint32(len(slice157))
+		result158 := witRuntime.Allocate(pinner, uintptr(length159*(6*4)), 4)
+		for index, element := range slice157 {
+			base := unsafe.Add(result158, index*(6*4))
+			utf8155 := unsafe.Pointer(unsafe.StringData((element).Id))
+			pinner.Pin(utf8155)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8155)))
+
+			switch (element).Name.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (element).Name.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+				utf8156 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8156)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8156)))
+
+			default:
+				panic("unreachable")
+			}
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(length159)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(result158)))
+		*(*int32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = (((element).Value).Graph).Root
+		slice189 := (((element).Value).Value).ValueNodes
+		length191 := uint32(len(slice189))
+		result190 := witRuntime.Allocate(pinner, uintptr(length191*(16+4*4)), 8)
+		for index, element := range slice189 {
+			base := unsafe.Add(result190, index*(16+4*4))
+
+			switch element.Tag() {
+			case golem_core_types.SchemaValueNodeBoolValue:
+				payload := element.BoolValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+				var result160 int32
+				if payload {
+					result160 = 1
+				} else {
+					result160 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result160)
+
+			case golem_core_types.SchemaValueNodeS8Value:
+				payload := element.S8Value()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+			case golem_core_types.SchemaValueNodeS16Value:
+				payload := element.S16Value()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+			case golem_core_types.SchemaValueNodeS32Value:
+				payload := element.S32Value()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+			case golem_core_types.SchemaValueNodeS64Value:
+				payload := element.S64Value()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+			case golem_core_types.SchemaValueNodeU8Value:
+				payload := element.U8Value()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+			case golem_core_types.SchemaValueNodeU16Value:
+				payload := element.U16Value()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+			case golem_core_types.SchemaValueNodeU32Value:
+				payload := element.U32Value()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+			case golem_core_types.SchemaValueNodeU64Value:
+				payload := element.U64Value()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+			case golem_core_types.SchemaValueNodeF32Value:
+				payload := element.F32Value()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+				*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+			case golem_core_types.SchemaValueNodeF64Value:
+				payload := element.F64Value()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+				*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+			case golem_core_types.SchemaValueNodeCharValue:
+				payload := element.CharValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+			case golem_core_types.SchemaValueNodeStringValue:
+				payload := element.StringValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+				utf8161 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8161)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8161)))
+
+			case golem_core_types.SchemaValueNodeRecordValue:
+				payload := element.RecordValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+				slice162 := payload
+				length164 := uint32(len(slice162))
+				result163 := witRuntime.Allocate(pinner, uintptr(length164*4), 4)
+				for index, element := range slice162 {
+					base := unsafe.Add(result163, index*4)
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length164)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result163)))
+
+			case golem_core_types.SchemaValueNodeVariantValue:
+				payload := element.VariantValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).Case)
+
+				switch (payload).Payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaValueNodeEnumValue:
+				payload := element.EnumValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+			case golem_core_types.SchemaValueNodeFlagsValue:
+				payload := element.FlagsValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+				slice166 := payload
+				length168 := uint32(len(slice166))
+				result167 := witRuntime.Allocate(pinner, uintptr(length168*1), 1)
+				for index, element := range slice166 {
+					base := unsafe.Add(result167, index*1)
+					var result165 int32
+					if element {
+						result165 = 1
+					} else {
+						result165 = 0
+					}
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result165)
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length168)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result167)))
+
+			case golem_core_types.SchemaValueNodeTupleValue:
+				payload := element.TupleValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+				slice169 := payload
+				length171 := uint32(len(slice169))
+				result170 := witRuntime.Allocate(pinner, uintptr(length171*4), 4)
+				for index, element := range slice169 {
+					base := unsafe.Add(result170, index*4)
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length171)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result170)))
+
+			case golem_core_types.SchemaValueNodeListValue:
+				payload := element.ListValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+				slice172 := payload
+				length174 := uint32(len(slice172))
+				result173 := witRuntime.Allocate(pinner, uintptr(length174*4), 4)
+				for index, element := range slice172 {
+					base := unsafe.Add(result173, index*4)
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length174)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result173)))
+
+			case golem_core_types.SchemaValueNodeFixedListValue:
+				payload := element.FixedListValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+				slice175 := payload
+				length177 := uint32(len(slice175))
+				result176 := witRuntime.Allocate(pinner, uintptr(length177*4), 4)
+				for index, element := range slice175 {
+					base := unsafe.Add(result176, index*4)
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length177)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result176)))
+
+			case golem_core_types.SchemaValueNodeMapValue:
+				payload := element.MapValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+				slice178 := payload
+				length180 := uint32(len(slice178))
+				result179 := witRuntime.Allocate(pinner, uintptr(length180*8), 4)
+				for index, element := range slice178 {
+					base := unsafe.Add(result179, index*8)
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).Key
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (element).Value
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length180)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result179)))
+
+			case golem_core_types.SchemaValueNodeOptionValue:
+				payload := element.OptionValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaValueNodeResultValue:
+				payload := element.ResultValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+
+				switch payload.Tag() {
+				case golem_core_types.ResultValuePayloadOkValue:
+					payload := payload.OkValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.ResultValuePayloadErrValue:
+					payload := payload.ErrValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaValueNodeTextValue:
+				payload := element.TextValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+				utf8181 := unsafe.Pointer(unsafe.StringData((payload).Text))
+				pinner.Pin(utf8181)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8181)))
+
+				switch (payload).Language.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Language.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+					utf8182 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8182)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8182)))
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaValueNodeBinaryValue:
+				payload := element.BinaryValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+				data183 := unsafe.Pointer(unsafe.SliceData((payload).Bytes))
+				pinner.Pin(data183)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data183)))
+
+				switch (payload).MimeType.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).MimeType.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+					utf8184 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8184)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8184)))
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaValueNodePathValue:
+				payload := element.PathValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+				utf8185 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8185)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8185)))
+
+			case golem_core_types.SchemaValueNodeUrlValue:
+				payload := element.UrlValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+				utf8186 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8186)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8186)))
+
+			case golem_core_types.SchemaValueNodeDatetimeValue:
+				payload := element.DatetimeValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Seconds
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = int32((payload).Nanoseconds)
+
+			case golem_core_types.SchemaValueNodeDurationValue:
+				payload := element.DurationValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Nanoseconds
+
+			case golem_core_types.SchemaValueNodeQuantityValueNode:
+				payload := element.QuantityValueNode()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Mantissa
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Scale
+				utf8187 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+				pinner.Pin(utf8187)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uint32(len((payload).Unit)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))) = uint32(uintptr(uintptr(utf8187)))
+
+			case golem_core_types.SchemaValueNodeUnionValue:
+				payload := element.UnionValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+				utf8188 := unsafe.Pointer(unsafe.StringData((payload).Tag))
+				pinner.Pin(utf8188)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8188)))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Body
+
+			case golem_core_types.SchemaValueNodeSecretValue:
+				payload := element.SecretValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+			case golem_core_types.SchemaValueNodeQuotaTokenHandle:
+				payload := element.QuotaTokenHandle()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+			default:
+				panic("unreachable")
+			}
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(length191)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(result190)))
+		*(*int32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = (((element).Value).Value).Root
+
+	}
+
+	result195 := wasm_import_constructor_wasm_rpc(uintptr(utf8), uint32(len(agentTypeName)), uintptr(result26), length27, (constructor).Root, option, option28, option29, uintptr(result193), length194)
+	return WasmRpcFromOwnHandle(int32(uintptr(result195)))
+
+}
+
+//go:wasmimport golem:agent/host@2.0.0 [method]wasm-rpc.invoke-and-await
+func wasm_import_method_wasm_rpc_invoke_and_await(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 int32, arg6 uintptr)
+
+func (self *WasmRpc) InvokeAndAwait(methodName string, input golem_core_types.SchemaValueTree) witTypes.Result[InvocationResultWithMetadata, RpcError] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (11 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(methodName))
+	pinner.Pin(utf8)
+	slice25 := (input).ValueNodes
+	length27 := uint32(len(slice25))
+	result26 := witRuntime.Allocate(pinner, uintptr(length27*(16+4*4)), 8)
+	for index, element := range slice25 {
+		base := unsafe.Add(result26, index*(16+4*4))
+
+		switch element.Tag() {
+		case golem_core_types.SchemaValueNodeBoolValue:
+			payload := element.BoolValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case golem_core_types.SchemaValueNodeS8Value:
+			payload := element.S8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS16Value:
+			payload := element.S16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS32Value:
+			payload := element.S32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeS64Value:
+			payload := element.S64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeU8Value:
+			payload := element.U8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU16Value:
+			payload := element.U16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU32Value:
+			payload := element.U32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeU64Value:
+			payload := element.U64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case golem_core_types.SchemaValueNodeF32Value:
+			payload := element.F32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeF64Value:
+			payload := element.F64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeCharValue:
+			payload := element.CharValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeStringValue:
+			payload := element.StringValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case golem_core_types.SchemaValueNodeRecordValue:
+			payload := element.RecordValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			slice := payload
+			length := uint32(len(slice))
+			result1 := witRuntime.Allocate(pinner, uintptr(length*4), 4)
+			for index, element := range slice {
+				base := unsafe.Add(result1, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result1)))
+
+		case golem_core_types.SchemaValueNodeVariantValue:
+			payload := element.VariantValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).Case)
+
+			switch (payload).Payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeEnumValue:
+			payload := element.EnumValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeFlagsValue:
+			payload := element.FlagsValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			slice3 := payload
+			length5 := uint32(len(slice3))
+			result4 := witRuntime.Allocate(pinner, uintptr(length5*1), 1)
+			for index, element := range slice3 {
+				base := unsafe.Add(result4, index*1)
+				var result2 int32
+				if element {
+					result2 = 1
+				} else {
+					result2 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result2)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length5)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result4)))
+
+		case golem_core_types.SchemaValueNodeTupleValue:
+			payload := element.TupleValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			slice6 := payload
+			length8 := uint32(len(slice6))
+			result7 := witRuntime.Allocate(pinner, uintptr(length8*4), 4)
+			for index, element := range slice6 {
+				base := unsafe.Add(result7, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length8)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result7)))
+
+		case golem_core_types.SchemaValueNodeListValue:
+			payload := element.ListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			slice9 := payload
+			length11 := uint32(len(slice9))
+			result10 := witRuntime.Allocate(pinner, uintptr(length11*4), 4)
+			for index, element := range slice9 {
+				base := unsafe.Add(result10, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length11)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result10)))
+
+		case golem_core_types.SchemaValueNodeFixedListValue:
+			payload := element.FixedListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			slice12 := payload
+			length14 := uint32(len(slice12))
+			result13 := witRuntime.Allocate(pinner, uintptr(length14*4), 4)
+			for index, element := range slice12 {
+				base := unsafe.Add(result13, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length14)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result13)))
+
+		case golem_core_types.SchemaValueNodeMapValue:
+			payload := element.MapValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			slice15 := payload
+			length17 := uint32(len(slice15))
+			result16 := witRuntime.Allocate(pinner, uintptr(length17*8), 4)
+			for index, element := range slice15 {
+				base := unsafe.Add(result16, index*8)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).Key
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (element).Value
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length17)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result16)))
+
+		case golem_core_types.SchemaValueNodeOptionValue:
+			payload := element.OptionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeResultValue:
+			payload := element.ResultValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+
+			switch payload.Tag() {
+			case golem_core_types.ResultValuePayloadOkValue:
+				payload := payload.OkValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.ResultValuePayloadErrValue:
+				payload := payload.ErrValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeTextValue:
+			payload := element.TextValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+			utf818 := unsafe.Pointer(unsafe.StringData((payload).Text))
+			pinner.Pin(utf818)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf818)))
+
+			switch (payload).Language.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Language.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf819 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf819)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf819)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeBinaryValue:
+			payload := element.BinaryValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+			data := unsafe.Pointer(unsafe.SliceData((payload).Bytes))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+			switch (payload).MimeType.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MimeType.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf820 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf820)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf820)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodePathValue:
+			payload := element.PathValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			utf821 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf821)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf821)))
+
+		case golem_core_types.SchemaValueNodeUrlValue:
+			payload := element.UrlValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			utf822 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf822)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf822)))
+
+		case golem_core_types.SchemaValueNodeDatetimeValue:
+			payload := element.DatetimeValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = int32((payload).Nanoseconds)
+
+		case golem_core_types.SchemaValueNodeDurationValue:
+			payload := element.DurationValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Nanoseconds
+
+		case golem_core_types.SchemaValueNodeQuantityValueNode:
+			payload := element.QuantityValueNode()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Mantissa
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Scale
+			utf823 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+			pinner.Pin(utf823)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uint32(len((payload).Unit)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))) = uint32(uintptr(uintptr(utf823)))
+
+		case golem_core_types.SchemaValueNodeUnionValue:
+			payload := element.UnionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			utf824 := unsafe.Pointer(unsafe.StringData((payload).Tag))
+			pinner.Pin(utf824)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf824)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Body
+
+		case golem_core_types.SchemaValueNodeSecretValue:
+			payload := element.SecretValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		case golem_core_types.SchemaValueNodeQuotaTokenHandle:
+			payload := element.QuotaTokenHandle()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_wasm_rpc_invoke_and_await((self).Handle(), uintptr(utf8), uint32(len(methodName)), uintptr(result26), length27, (input).Root, returnArea)
+	var result266 witTypes.Result[InvocationResultWithMetadata, RpcError]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+		var option51 witTypes.Option[golem_core_types.SchemaValueTree]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4)))) {
+		case 0:
+
+			option51 = witTypes.None[golem_core_types.SchemaValueTree]()
+		case 1:
+			result50 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (7 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (7 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (6 * 4))))), index*(16+4*4))
+				var variant49 golem_core_types.SchemaValueNode
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+				case 1:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 2:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 3:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 4:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 5:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 6:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 7:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 8:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 9:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 10:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 11:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 12:
+					value29 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant49 = golem_core_types.MakeSchemaValueNodeStringValue(value29)
+
+				case 13:
+					result30 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result30 = append(result30, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant49 = golem_core_types.MakeSchemaValueNodeRecordValue(result30)
+
+				case 14:
+					var option witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+					case 0:
+
+						option = witTypes.None[int32]()
+					case 1:
+
+						option = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+					default:
+						panic("unreachable")
+					}
+
+					variant49 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option})
+
+				case 15:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 16:
+					result31 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+						result31 = append(result31, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+					}
+
+					variant49 = golem_core_types.MakeSchemaValueNodeFlagsValue(result31)
+
+				case 17:
+					result32 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result32 = append(result32, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant49 = golem_core_types.MakeSchemaValueNodeTupleValue(result32)
+
+				case 18:
+					result33 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result33 = append(result33, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant49 = golem_core_types.MakeSchemaValueNodeListValue(result33)
+
+				case 19:
+					result34 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result34 = append(result34, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant49 = golem_core_types.MakeSchemaValueNodeFixedListValue(result34)
+
+				case 20:
+					result35 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+						result35 = append(result35, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+					}
+
+					variant49 = golem_core_types.MakeSchemaValueNodeMapValue(result35)
+
+				case 21:
+					var option36 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option36 = witTypes.None[int32]()
+					case 1:
+
+						option36 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+
+					variant49 = golem_core_types.MakeSchemaValueNodeOptionValue(option36)
+
+				case 22:
+					var variant golem_core_types.ResultValuePayload
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+						var option37 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+						case 0:
+
+							option37 = witTypes.None[int32]()
+						case 1:
+
+							option37 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+						default:
+							panic("unreachable")
+						}
+
+						variant = golem_core_types.MakeResultValuePayloadOkValue(option37)
+
+					case 1:
+						var option38 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+						case 0:
+
+							option38 = witTypes.None[int32]()
+						case 1:
+
+							option38 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+						default:
+							panic("unreachable")
+						}
+
+						variant = golem_core_types.MakeResultValuePayloadErrValue(option38)
+
+					default:
+						panic("unreachable")
+					}
+
+					variant49 = golem_core_types.MakeSchemaValueNodeResultValue(variant)
+
+				case 23:
+					value39 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					var option41 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						option41 = witTypes.None[string]()
+					case 1:
+						value40 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+						option41 = witTypes.Some[string](value40)
+					default:
+						panic("unreachable")
+					}
+
+					variant49 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value39, option41})
+
+				case 24:
+					value42 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					var option44 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						option44 = witTypes.None[string]()
+					case 1:
+						value43 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+						option44 = witTypes.Some[string](value43)
+					default:
+						panic("unreachable")
+					}
+
+					variant49 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value42, option44})
+
+				case 25:
+					value45 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant49 = golem_core_types.MakeSchemaValueNodePathValue(value45)
+
+				case 26:
+					value46 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant49 = golem_core_types.MakeSchemaValueNodeUrlValue(value46)
+
+				case 27:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+				case 28:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+				case 29:
+					value47 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+					variant49 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value47})
+
+				case 30:
+					value48 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant49 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value48, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+				case 31:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+				case 32:
+
+					variant49 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+				default:
+					panic("unreachable")
+				}
+
+				result50 = append(result50, variant49)
+			}
+
+			option51 = witTypes.Some[golem_core_types.SchemaValueTree](golem_core_types.SchemaValueTree{result50, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (8 * 4)))})
+		default:
+			panic("unreachable")
+		}
+
+		result266 = witTypes.Ok[InvocationResultWithMetadata, RpcError](InvocationResultWithMetadata{InvocationMetadata{value, value28}, option51})
+	case 1:
+		var variant265 RpcError
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value52 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant265 = MakeRpcErrorProtocolError(value52)
+
+		case 1:
+			value53 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant265 = MakeRpcErrorDenied(value53)
+
+		case 2:
+			value54 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant265 = MakeRpcErrorNotFound(value54)
+
+		case 3:
+			value55 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant265 = MakeRpcErrorRemoteInternalError(value55)
+
+		case 4:
+			var variant264 golem_agent_common.AgentError
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+				value56 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				variant264 = golem_agent_common.MakeAgentErrorInvalidInput(value56)
+
+			case 1:
+				value57 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				variant264 = golem_agent_common.MakeAgentErrorInvalidMethod(value57)
+
+			case 2:
+				value58 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				variant264 = golem_agent_common.MakeAgentErrorInvalidType(value58)
+
+			case 3:
+				value59 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				variant264 = golem_agent_common.MakeAgentErrorInvalidAgentId(value59)
+
+			case 4:
+				result235 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))), index*(56+22*4))
+					var variant223 golem_core_types.SchemaTypeBody
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 1:
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+					case 2:
+						var option66 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option66 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option61 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option61 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant60 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant60 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant60 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant60 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option61 = witTypes.Some[golem_core_types.NumericBound](variant60)
+							default:
+								panic("unreachable")
+							}
+							var option63 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option63 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant62 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant62 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant62 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant62 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option63 = witTypes.Some[golem_core_types.NumericBound](variant62)
+							default:
+								panic("unreachable")
+							}
+							var option65 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option65 = witTypes.None[string]()
+							case 1:
+								value64 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option65 = witTypes.Some[string](value64)
+							default:
+								panic("unreachable")
+							}
+
+							option66 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option61, option63, option65})
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyS8Type(option66)
+
+					case 3:
+						var option73 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option73 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option68 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option68 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant67 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant67 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant67 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant67 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option68 = witTypes.Some[golem_core_types.NumericBound](variant67)
+							default:
+								panic("unreachable")
+							}
+							var option70 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option70 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant69 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant69 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant69 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant69 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option70 = witTypes.Some[golem_core_types.NumericBound](variant69)
+							default:
+								panic("unreachable")
+							}
+							var option72 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option72 = witTypes.None[string]()
+							case 1:
+								value71 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option72 = witTypes.Some[string](value71)
+							default:
+								panic("unreachable")
+							}
+
+							option73 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option68, option70, option72})
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyS16Type(option73)
+
+					case 4:
+						var option80 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option80 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option75 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option75 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant74 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant74 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant74 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant74 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option75 = witTypes.Some[golem_core_types.NumericBound](variant74)
+							default:
+								panic("unreachable")
+							}
+							var option77 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option77 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant76 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant76 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant76 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant76 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option77 = witTypes.Some[golem_core_types.NumericBound](variant76)
+							default:
+								panic("unreachable")
+							}
+							var option79 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option79 = witTypes.None[string]()
+							case 1:
+								value78 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option79 = witTypes.Some[string](value78)
+							default:
+								panic("unreachable")
+							}
+
+							option80 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option75, option77, option79})
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyS32Type(option80)
+
+					case 5:
+						var option87 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option87 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option82 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option82 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant81 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant81 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant81 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant81 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option82 = witTypes.Some[golem_core_types.NumericBound](variant81)
+							default:
+								panic("unreachable")
+							}
+							var option84 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option84 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant83 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant83 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant83 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant83 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option84 = witTypes.Some[golem_core_types.NumericBound](variant83)
+							default:
+								panic("unreachable")
+							}
+							var option86 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option86 = witTypes.None[string]()
+							case 1:
+								value85 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option86 = witTypes.Some[string](value85)
+							default:
+								panic("unreachable")
+							}
+
+							option87 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option82, option84, option86})
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyS64Type(option87)
+
+					case 6:
+						var option94 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option94 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option89 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option89 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant88 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant88 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant88 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant88 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option89 = witTypes.Some[golem_core_types.NumericBound](variant88)
+							default:
+								panic("unreachable")
+							}
+							var option91 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option91 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant90 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant90 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant90 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant90 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option91 = witTypes.Some[golem_core_types.NumericBound](variant90)
+							default:
+								panic("unreachable")
+							}
+							var option93 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option93 = witTypes.None[string]()
+							case 1:
+								value92 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option93 = witTypes.Some[string](value92)
+							default:
+								panic("unreachable")
+							}
+
+							option94 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option89, option91, option93})
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyU8Type(option94)
+
+					case 7:
+						var option101 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option101 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option96 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option96 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant95 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant95 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant95 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant95 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option96 = witTypes.Some[golem_core_types.NumericBound](variant95)
+							default:
+								panic("unreachable")
+							}
+							var option98 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option98 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant97 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant97 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant97 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant97 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option98 = witTypes.Some[golem_core_types.NumericBound](variant97)
+							default:
+								panic("unreachable")
+							}
+							var option100 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option100 = witTypes.None[string]()
+							case 1:
+								value99 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option100 = witTypes.Some[string](value99)
+							default:
+								panic("unreachable")
+							}
+
+							option101 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option96, option98, option100})
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyU16Type(option101)
+
+					case 8:
+						var option108 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option108 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option103 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option103 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant102 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant102 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant102 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant102 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option103 = witTypes.Some[golem_core_types.NumericBound](variant102)
+							default:
+								panic("unreachable")
+							}
+							var option105 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option105 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant104 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant104 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant104 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant104 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option105 = witTypes.Some[golem_core_types.NumericBound](variant104)
+							default:
+								panic("unreachable")
+							}
+							var option107 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option107 = witTypes.None[string]()
+							case 1:
+								value106 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option107 = witTypes.Some[string](value106)
+							default:
+								panic("unreachable")
+							}
+
+							option108 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option103, option105, option107})
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyU32Type(option108)
+
+					case 9:
+						var option115 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option115 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option110 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option110 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant109 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant109 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant109 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant109 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option110 = witTypes.Some[golem_core_types.NumericBound](variant109)
+							default:
+								panic("unreachable")
+							}
+							var option112 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option112 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant111 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant111 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant111 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant111 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option112 = witTypes.Some[golem_core_types.NumericBound](variant111)
+							default:
+								panic("unreachable")
+							}
+							var option114 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option114 = witTypes.None[string]()
+							case 1:
+								value113 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option114 = witTypes.Some[string](value113)
+							default:
+								panic("unreachable")
+							}
+
+							option115 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option110, option112, option114})
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyU64Type(option115)
+
+					case 10:
+						var option122 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option122 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option117 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option117 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant116 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant116 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant116 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant116 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option117 = witTypes.Some[golem_core_types.NumericBound](variant116)
+							default:
+								panic("unreachable")
+							}
+							var option119 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option119 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant118 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant118 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant118 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant118 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option119 = witTypes.Some[golem_core_types.NumericBound](variant118)
+							default:
+								panic("unreachable")
+							}
+							var option121 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option121 = witTypes.None[string]()
+							case 1:
+								value120 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option121 = witTypes.Some[string](value120)
+							default:
+								panic("unreachable")
+							}
+
+							option122 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option117, option119, option121})
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyF32Type(option122)
+
+					case 11:
+						var option129 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option129 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option124 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option124 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant123 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant123 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant123 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant123 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option124 = witTypes.Some[golem_core_types.NumericBound](variant123)
+							default:
+								panic("unreachable")
+							}
+							var option126 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option126 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant125 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant125 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant125 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant125 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option126 = witTypes.Some[golem_core_types.NumericBound](variant125)
+							default:
+								panic("unreachable")
+							}
+							var option128 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option128 = witTypes.None[string]()
+							case 1:
+								value127 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option128 = witTypes.Some[string](value127)
+							default:
+								panic("unreachable")
+							}
+
+							option129 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option124, option126, option128})
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyF64Type(option129)
+
+					case 12:
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+					case 13:
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+					case 14:
+						result142 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+							value130 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var option132 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+							case 0:
+
+								option132 = witTypes.None[string]()
+							case 1:
+								value131 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								option132 = witTypes.Some[string](value131)
+							default:
+								panic("unreachable")
+							}
+							result134 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+								value133 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result134 = append(result134, value133)
+							}
+
+							result136 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+								value135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result136 = append(result136, value135)
+							}
+
+							var option138 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+							case 0:
+
+								option138 = witTypes.None[string]()
+							case 1:
+								value137 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+								option138 = witTypes.Some[string](value137)
+							default:
+								panic("unreachable")
+							}
+							var option141 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+							case 0:
+
+								option141 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant140 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+								case 0:
+
+									variant140 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant140 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant140 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value139 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+									variant140 = golem_core_types.MakeRoleOther(value139)
+
+								default:
+									panic("unreachable")
+								}
+
+								option141 = witTypes.Some[golem_core_types.Role](variant140)
+							default:
+								panic("unreachable")
+							}
+
+							result142 = append(result142, golem_core_types.NamedFieldType{value130, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option132, result134, result136, option138, option141}})
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyRecordType(result142)
+
+					case 15:
+						result156 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+							value143 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var option144 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+							case 0:
+
+								option144 = witTypes.None[int32]()
+							case 1:
+
+								option144 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+							default:
+								panic("unreachable")
+							}
+							var option146 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option146 = witTypes.None[string]()
+							case 1:
+								value145 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option146 = witTypes.Some[string](value145)
+							default:
+								panic("unreachable")
+							}
+							result148 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+								value147 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result148 = append(result148, value147)
+							}
+
+							result150 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+								value149 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result150 = append(result150, value149)
+							}
+
+							var option152 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+							case 0:
+
+								option152 = witTypes.None[string]()
+							case 1:
+								value151 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+								option152 = witTypes.Some[string](value151)
+							default:
+								panic("unreachable")
+							}
+							var option155 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+							case 0:
+
+								option155 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant154 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+								case 0:
+
+									variant154 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant154 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant154 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value153 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+									variant154 = golem_core_types.MakeRoleOther(value153)
+
+								default:
+									panic("unreachable")
+								}
+
+								option155 = witTypes.Some[golem_core_types.Role](variant154)
+							default:
+								panic("unreachable")
+							}
+
+							result156 = append(result156, golem_core_types.VariantCaseType{value143, option144, golem_core_types.MetadataEnvelope{option146, result148, result150, option152, option155}})
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyVariantType(result156)
+
+					case 16:
+						result158 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+							value157 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result158 = append(result158, value157)
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyEnumType(result158)
+
+					case 17:
+						result160 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+							value159 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result160 = append(result160, value159)
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyFlagsType(result160)
+
+					case 18:
+						result161 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result161 = append(result161, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyTupleType(result161)
+
+					case 19:
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 20:
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+					case 21:
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 22:
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 23:
+						var option162 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option162 = witTypes.None[int32]()
+						case 1:
+
+							option162 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+						var option163 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option163 = witTypes.None[int32]()
+						case 1:
+
+							option163 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option162, option163})
+
+					case 24:
+						var option166 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option166 = witTypes.None[[]string]()
+						case 1:
+							result165 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value164 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result165 = append(result165, value164)
+							}
+
+							option166 = witTypes.Some[[]string](result165)
+						default:
+							panic("unreachable")
+						}
+						var option167 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option167 = witTypes.None[uint32]()
+						case 1:
+
+							option167 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option168 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+						case 0:
+
+							option168 = witTypes.None[uint32]()
+						case 1:
+
+							option168 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option170 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+						case 0:
+
+							option170 = witTypes.None[string]()
+						case 1:
+							value169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+							option170 = witTypes.Some[string](value169)
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option166, option167, option168, option170})
+
+					case 25:
+						var option173 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option173 = witTypes.None[[]string]()
+						case 1:
+							result172 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value171 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result172 = append(result172, value171)
+							}
+
+							option173 = witTypes.Some[[]string](result172)
+						default:
+							panic("unreachable")
+						}
+						var option174 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option174 = witTypes.None[uint32]()
+						case 1:
+
+							option174 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option175 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+						case 0:
+
+							option175 = witTypes.None[uint32]()
+						case 1:
+
+							option175 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option173, option174, option175})
+
+					case 26:
+						var option178 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+						case 0:
+
+							option178 = witTypes.None[[]string]()
+						case 1:
+							result177 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result177 = append(result177, value176)
+							}
+
+							option178 = witTypes.Some[[]string](result177)
+						default:
+							panic("unreachable")
+						}
+						var option181 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+						case 0:
+
+							option181 = witTypes.None[[]string]()
+						case 1:
+							result180 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+								value179 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result180 = append(result180, value179)
+							}
+
+							option181 = witTypes.Some[[]string](result180)
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option178, option181})
+
+					case 27:
+						var option184 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option184 = witTypes.None[[]string]()
+						case 1:
+							result183 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value182 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result183 = append(result183, value182)
+							}
+
+							option184 = witTypes.Some[[]string](result183)
+						default:
+							panic("unreachable")
+						}
+						var option187 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option187 = witTypes.None[[]string]()
+						case 1:
+							result186 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+								value185 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result186 = append(result186, value185)
+							}
+
+							option187 = witTypes.Some[[]string](result186)
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option184, option187})
+
+					case 28:
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+					case 29:
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+					case 30:
+						value188 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						result190 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+							value189 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result190 = append(result190, value189)
+						}
+
+						var option192 witTypes.Option[golem_core_types.QuantityValue]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+						case 0:
+
+							option192 = witTypes.None[golem_core_types.QuantityValue]()
+						case 1:
+							value191 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+							option192 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value191})
+						default:
+							panic("unreachable")
+						}
+						var option194 witTypes.Option[golem_core_types.QuantityValue]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+						case 0:
+
+							option194 = witTypes.None[golem_core_types.QuantityValue]()
+						case 1:
+							value193 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+							option194 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value193})
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value188, result190, option192, option194})
+
+					case 31:
+						result216 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+							value195 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var variant204 golem_core_types.DiscriminatorRule
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+							case 0:
+								value196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant204 = golem_core_types.MakeDiscriminatorRulePrefix(value196)
+
+							case 1:
+								value197 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant204 = golem_core_types.MakeDiscriminatorRuleSuffix(value197)
+
+							case 2:
+								value198 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant204 = golem_core_types.MakeDiscriminatorRuleContains(value198)
+
+							case 3:
+								value199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant204 = golem_core_types.MakeDiscriminatorRuleRegex(value199)
+
+							case 4:
+								value200 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+								var option202 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+								case 0:
+
+									option202 = witTypes.None[string]()
+								case 1:
+									value201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+									option202 = witTypes.Some[string](value201)
+								default:
+									panic("unreachable")
+								}
+
+								variant204 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value200, option202})
+
+							case 5:
+								value203 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant204 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value203)
+
+							default:
+								panic("unreachable")
+							}
+							var option206 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+							case 0:
+
+								option206 = witTypes.None[string]()
+							case 1:
+								value205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+								option206 = witTypes.Some[string](value205)
+							default:
+								panic("unreachable")
+							}
+							result208 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+								value207 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result208 = append(result208, value207)
+							}
+
+							result210 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+								value209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result210 = append(result210, value209)
+							}
+
+							var option212 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+							case 0:
+
+								option212 = witTypes.None[string]()
+							case 1:
+								value211 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+								option212 = witTypes.Some[string](value211)
+							default:
+								panic("unreachable")
+							}
+							var option215 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+							case 0:
+
+								option215 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant214 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+								case 0:
+
+									variant214 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant214 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant214 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value213 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+									variant214 = golem_core_types.MakeRoleOther(value213)
+
+								default:
+									panic("unreachable")
+								}
+
+								option215 = witTypes.Some[golem_core_types.Role](variant214)
+							default:
+								panic("unreachable")
+							}
+
+							result216 = append(result216, golem_core_types.UnionBranch{value195, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant204, golem_core_types.MetadataEnvelope{option206, result208, result210, option212, option215}})
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result216})
+
+					case 32:
+						var option218 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+						case 0:
+
+							option218 = witTypes.None[string]()
+						case 1:
+							value217 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+							option218 = witTypes.Some[string](value217)
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option218})
+
+					case 33:
+						var option220 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option220 = witTypes.None[string]()
+						case 1:
+							value219 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+							option220 = witTypes.Some[string](value219)
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option220})
+
+					case 34:
+						var option221 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option221 = witTypes.None[int32]()
+						case 1:
+
+							option221 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyFutureType(option221)
+
+					case 35:
+						var option222 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option222 = witTypes.None[int32]()
+						case 1:
+
+							option222 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant223 = golem_core_types.MakeSchemaTypeBodyStreamType(option222)
+
+					default:
+						panic("unreachable")
+					}
+					var option225 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+					case 0:
+
+						option225 = witTypes.None[string]()
+					case 1:
+						value224 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+						option225 = witTypes.Some[string](value224)
+					default:
+						panic("unreachable")
+					}
+					result227 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+						value226 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result227 = append(result227, value226)
+					}
+
+					result229 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+						value228 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result229 = append(result229, value228)
+					}
+
+					var option231 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+					case 0:
+
+						option231 = witTypes.None[string]()
+					case 1:
+						value230 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+						option231 = witTypes.Some[string](value230)
+					default:
+						panic("unreachable")
+					}
+					var option234 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+					case 0:
+
+						option234 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant233 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+						case 0:
+
+							variant233 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant233 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant233 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value232 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+							variant233 = golem_core_types.MakeRoleOther(value232)
+
+						default:
+							panic("unreachable")
+						}
+
+						option234 = witTypes.Some[golem_core_types.Role](variant233)
+					default:
+						panic("unreachable")
+					}
+
+					result235 = append(result235, golem_core_types.SchemaTypeNode{variant223, golem_core_types.MetadataEnvelope{option225, result227, result229, option231, option234}})
+				}
+
+				result239 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (6 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (6 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4))))), index*(6*4))
+					value236 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var option238 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+
+						option238 = witTypes.None[string]()
+					case 1:
+						value237 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+						option238 = witTypes.Some[string](value237)
+					default:
+						panic("unreachable")
+					}
+
+					result239 = append(result239, golem_core_types.SchemaTypeDef{value236, option238, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+				}
+
+				result263 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (9 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (9 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 * 4))))), index*(16+4*4))
+					var variant262 golem_core_types.SchemaValueNode
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+					case 1:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 2:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 3:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 4:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 5:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 6:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 7:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 8:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 9:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 10:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 11:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 12:
+						value240 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant262 = golem_core_types.MakeSchemaValueNodeStringValue(value240)
+
+					case 13:
+						result241 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result241 = append(result241, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant262 = golem_core_types.MakeSchemaValueNodeRecordValue(result241)
+
+					case 14:
+						var option242 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+						case 0:
+
+							option242 = witTypes.None[int32]()
+						case 1:
+
+							option242 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+						default:
+							panic("unreachable")
+						}
+
+						variant262 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option242})
+
+					case 15:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 16:
+						result243 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+							result243 = append(result243, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+						}
+
+						variant262 = golem_core_types.MakeSchemaValueNodeFlagsValue(result243)
+
+					case 17:
+						result244 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result244 = append(result244, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant262 = golem_core_types.MakeSchemaValueNodeTupleValue(result244)
+
+					case 18:
+						result245 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result245 = append(result245, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant262 = golem_core_types.MakeSchemaValueNodeListValue(result245)
+
+					case 19:
+						result246 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result246 = append(result246, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant262 = golem_core_types.MakeSchemaValueNodeFixedListValue(result246)
+
+					case 20:
+						result247 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+							result247 = append(result247, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+						}
+
+						variant262 = golem_core_types.MakeSchemaValueNodeMapValue(result247)
+
+					case 21:
+						var option248 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option248 = witTypes.None[int32]()
+						case 1:
+
+							option248 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant262 = golem_core_types.MakeSchemaValueNodeOptionValue(option248)
+
+					case 22:
+						var variant251 golem_core_types.ResultValuePayload
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+							var option249 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option249 = witTypes.None[int32]()
+							case 1:
+
+								option249 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant251 = golem_core_types.MakeResultValuePayloadOkValue(option249)
+
+						case 1:
+							var option250 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option250 = witTypes.None[int32]()
+							case 1:
+
+								option250 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant251 = golem_core_types.MakeResultValuePayloadErrValue(option250)
+
+						default:
+							panic("unreachable")
+						}
+
+						variant262 = golem_core_types.MakeSchemaValueNodeResultValue(variant251)
+
+					case 23:
+						value252 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var option254 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option254 = witTypes.None[string]()
+						case 1:
+							value253 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option254 = witTypes.Some[string](value253)
+						default:
+							panic("unreachable")
+						}
+
+						variant262 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value252, option254})
+
+					case 24:
+						value255 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var option257 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option257 = witTypes.None[string]()
+						case 1:
+							value256 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option257 = witTypes.Some[string](value256)
+						default:
+							panic("unreachable")
+						}
+
+						variant262 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value255, option257})
+
+					case 25:
+						value258 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant262 = golem_core_types.MakeSchemaValueNodePathValue(value258)
+
+					case 26:
+						value259 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant262 = golem_core_types.MakeSchemaValueNodeUrlValue(value259)
+
+					case 27:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+					case 28:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+					case 29:
+						value260 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						variant262 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value260})
+
+					case 30:
+						value261 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant262 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value261, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+					case 31:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+					case 32:
+
+						variant262 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+					default:
+						panic("unreachable")
+					}
+
+					result263 = append(result263, variant262)
+				}
+
+				variant264 = golem_agent_common.MakeAgentErrorCustomError(golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result235, result239, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (7 * 4)))}, golem_core_types.SchemaValueTree{result263, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (10 * 4)))}})
+
+			default:
+				panic("unreachable")
+			}
+
+			variant265 = MakeRpcErrorRemoteAgentError(variant264)
+
+		default:
+			panic("unreachable")
+		}
+
+		result266 = witTypes.Err[InvocationResultWithMetadata, RpcError](variant265)
+	default:
+		panic("unreachable")
+	}
+	result267 := result266
+	return result267
+
+}
+
+//go:wasmimport golem:agent/host@2.0.0 [method]wasm-rpc.invoke
+func wasm_import_method_wasm_rpc_invoke(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 int32, arg6 uintptr)
+
+func (self *WasmRpc) Invoke(methodName string, input golem_core_types.SchemaValueTree) witTypes.Result[InvocationMetadata, RpcError] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (11 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(methodName))
+	pinner.Pin(utf8)
+	slice25 := (input).ValueNodes
+	length27 := uint32(len(slice25))
+	result26 := witRuntime.Allocate(pinner, uintptr(length27*(16+4*4)), 8)
+	for index, element := range slice25 {
+		base := unsafe.Add(result26, index*(16+4*4))
+
+		switch element.Tag() {
+		case golem_core_types.SchemaValueNodeBoolValue:
+			payload := element.BoolValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case golem_core_types.SchemaValueNodeS8Value:
+			payload := element.S8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS16Value:
+			payload := element.S16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS32Value:
+			payload := element.S32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeS64Value:
+			payload := element.S64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeU8Value:
+			payload := element.U8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU16Value:
+			payload := element.U16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU32Value:
+			payload := element.U32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeU64Value:
+			payload := element.U64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case golem_core_types.SchemaValueNodeF32Value:
+			payload := element.F32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeF64Value:
+			payload := element.F64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeCharValue:
+			payload := element.CharValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeStringValue:
+			payload := element.StringValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case golem_core_types.SchemaValueNodeRecordValue:
+			payload := element.RecordValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			slice := payload
+			length := uint32(len(slice))
+			result1 := witRuntime.Allocate(pinner, uintptr(length*4), 4)
+			for index, element := range slice {
+				base := unsafe.Add(result1, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result1)))
+
+		case golem_core_types.SchemaValueNodeVariantValue:
+			payload := element.VariantValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).Case)
+
+			switch (payload).Payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeEnumValue:
+			payload := element.EnumValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeFlagsValue:
+			payload := element.FlagsValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			slice3 := payload
+			length5 := uint32(len(slice3))
+			result4 := witRuntime.Allocate(pinner, uintptr(length5*1), 1)
+			for index, element := range slice3 {
+				base := unsafe.Add(result4, index*1)
+				var result2 int32
+				if element {
+					result2 = 1
+				} else {
+					result2 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result2)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length5)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result4)))
+
+		case golem_core_types.SchemaValueNodeTupleValue:
+			payload := element.TupleValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			slice6 := payload
+			length8 := uint32(len(slice6))
+			result7 := witRuntime.Allocate(pinner, uintptr(length8*4), 4)
+			for index, element := range slice6 {
+				base := unsafe.Add(result7, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length8)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result7)))
+
+		case golem_core_types.SchemaValueNodeListValue:
+			payload := element.ListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			slice9 := payload
+			length11 := uint32(len(slice9))
+			result10 := witRuntime.Allocate(pinner, uintptr(length11*4), 4)
+			for index, element := range slice9 {
+				base := unsafe.Add(result10, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length11)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result10)))
+
+		case golem_core_types.SchemaValueNodeFixedListValue:
+			payload := element.FixedListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			slice12 := payload
+			length14 := uint32(len(slice12))
+			result13 := witRuntime.Allocate(pinner, uintptr(length14*4), 4)
+			for index, element := range slice12 {
+				base := unsafe.Add(result13, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length14)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result13)))
+
+		case golem_core_types.SchemaValueNodeMapValue:
+			payload := element.MapValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			slice15 := payload
+			length17 := uint32(len(slice15))
+			result16 := witRuntime.Allocate(pinner, uintptr(length17*8), 4)
+			for index, element := range slice15 {
+				base := unsafe.Add(result16, index*8)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).Key
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (element).Value
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length17)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result16)))
+
+		case golem_core_types.SchemaValueNodeOptionValue:
+			payload := element.OptionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeResultValue:
+			payload := element.ResultValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+
+			switch payload.Tag() {
+			case golem_core_types.ResultValuePayloadOkValue:
+				payload := payload.OkValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.ResultValuePayloadErrValue:
+				payload := payload.ErrValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeTextValue:
+			payload := element.TextValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+			utf818 := unsafe.Pointer(unsafe.StringData((payload).Text))
+			pinner.Pin(utf818)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf818)))
+
+			switch (payload).Language.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Language.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf819 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf819)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf819)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeBinaryValue:
+			payload := element.BinaryValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+			data := unsafe.Pointer(unsafe.SliceData((payload).Bytes))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+			switch (payload).MimeType.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MimeType.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf820 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf820)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf820)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodePathValue:
+			payload := element.PathValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			utf821 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf821)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf821)))
+
+		case golem_core_types.SchemaValueNodeUrlValue:
+			payload := element.UrlValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			utf822 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf822)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf822)))
+
+		case golem_core_types.SchemaValueNodeDatetimeValue:
+			payload := element.DatetimeValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = int32((payload).Nanoseconds)
+
+		case golem_core_types.SchemaValueNodeDurationValue:
+			payload := element.DurationValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Nanoseconds
+
+		case golem_core_types.SchemaValueNodeQuantityValueNode:
+			payload := element.QuantityValueNode()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Mantissa
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Scale
+			utf823 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+			pinner.Pin(utf823)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uint32(len((payload).Unit)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))) = uint32(uintptr(uintptr(utf823)))
+
+		case golem_core_types.SchemaValueNodeUnionValue:
+			payload := element.UnionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			utf824 := unsafe.Pointer(unsafe.StringData((payload).Tag))
+			pinner.Pin(utf824)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf824)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Body
+
+		case golem_core_types.SchemaValueNodeSecretValue:
+			payload := element.SecretValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		case golem_core_types.SchemaValueNodeQuotaTokenHandle:
+			payload := element.QuotaTokenHandle()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_wasm_rpc_invoke((self).Handle(), uintptr(utf8), uint32(len(methodName)), uintptr(result26), length27, (input).Root, returnArea)
+	var result241 witTypes.Result[InvocationMetadata, RpcError]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+		result241 = witTypes.Ok[InvocationMetadata, RpcError](InvocationMetadata{value, value28})
+	case 1:
+		var variant240 RpcError
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value29 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant240 = MakeRpcErrorProtocolError(value29)
+
+		case 1:
+			value30 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant240 = MakeRpcErrorDenied(value30)
+
+		case 2:
+			value31 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant240 = MakeRpcErrorNotFound(value31)
+
+		case 3:
+			value32 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant240 = MakeRpcErrorRemoteInternalError(value32)
+
+		case 4:
+			var variant239 golem_agent_common.AgentError
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+				value33 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				variant239 = golem_agent_common.MakeAgentErrorInvalidInput(value33)
+
+			case 1:
+				value34 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				variant239 = golem_agent_common.MakeAgentErrorInvalidMethod(value34)
+
+			case 2:
+				value35 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				variant239 = golem_agent_common.MakeAgentErrorInvalidType(value35)
+
+			case 3:
+				value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				variant239 = golem_agent_common.MakeAgentErrorInvalidAgentId(value36)
+
+			case 4:
+				result210 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))), index*(56+22*4))
+					var variant198 golem_core_types.SchemaTypeBody
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 1:
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+					case 2:
+						var option41 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option41 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option = witTypes.Some[golem_core_types.NumericBound](variant)
+							default:
+								panic("unreachable")
+							}
+							var option38 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option38 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant37 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant37 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant37 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant37 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option38 = witTypes.Some[golem_core_types.NumericBound](variant37)
+							default:
+								panic("unreachable")
+							}
+							var option40 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option40 = witTypes.None[string]()
+							case 1:
+								value39 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option40 = witTypes.Some[string](value39)
+							default:
+								panic("unreachable")
+							}
+
+							option41 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option, option38, option40})
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyS8Type(option41)
+
+					case 3:
+						var option48 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option48 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option43 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option43 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant42 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant42 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant42 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant42 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option43 = witTypes.Some[golem_core_types.NumericBound](variant42)
+							default:
+								panic("unreachable")
+							}
+							var option45 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option45 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant44 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant44 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant44 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant44 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option45 = witTypes.Some[golem_core_types.NumericBound](variant44)
+							default:
+								panic("unreachable")
+							}
+							var option47 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option47 = witTypes.None[string]()
+							case 1:
+								value46 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option47 = witTypes.Some[string](value46)
+							default:
+								panic("unreachable")
+							}
+
+							option48 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option43, option45, option47})
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyS16Type(option48)
+
+					case 4:
+						var option55 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option55 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option50 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option50 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant49 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant49 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant49 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant49 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option50 = witTypes.Some[golem_core_types.NumericBound](variant49)
+							default:
+								panic("unreachable")
+							}
+							var option52 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option52 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant51 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant51 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant51 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant51 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option52 = witTypes.Some[golem_core_types.NumericBound](variant51)
+							default:
+								panic("unreachable")
+							}
+							var option54 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option54 = witTypes.None[string]()
+							case 1:
+								value53 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option54 = witTypes.Some[string](value53)
+							default:
+								panic("unreachable")
+							}
+
+							option55 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option50, option52, option54})
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyS32Type(option55)
+
+					case 5:
+						var option62 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option62 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option57 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option57 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant56 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant56 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant56 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant56 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option57 = witTypes.Some[golem_core_types.NumericBound](variant56)
+							default:
+								panic("unreachable")
+							}
+							var option59 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option59 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant58 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant58 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant58 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant58 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option59 = witTypes.Some[golem_core_types.NumericBound](variant58)
+							default:
+								panic("unreachable")
+							}
+							var option61 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option61 = witTypes.None[string]()
+							case 1:
+								value60 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option61 = witTypes.Some[string](value60)
+							default:
+								panic("unreachable")
+							}
+
+							option62 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option57, option59, option61})
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyS64Type(option62)
+
+					case 6:
+						var option69 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option69 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option64 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option64 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant63 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant63 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant63 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant63 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option64 = witTypes.Some[golem_core_types.NumericBound](variant63)
+							default:
+								panic("unreachable")
+							}
+							var option66 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option66 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant65 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant65 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant65 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant65 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option66 = witTypes.Some[golem_core_types.NumericBound](variant65)
+							default:
+								panic("unreachable")
+							}
+							var option68 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option68 = witTypes.None[string]()
+							case 1:
+								value67 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option68 = witTypes.Some[string](value67)
+							default:
+								panic("unreachable")
+							}
+
+							option69 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option64, option66, option68})
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyU8Type(option69)
+
+					case 7:
+						var option76 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option76 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option71 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option71 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant70 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant70 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant70 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant70 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option71 = witTypes.Some[golem_core_types.NumericBound](variant70)
+							default:
+								panic("unreachable")
+							}
+							var option73 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option73 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant72 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant72 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant72 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant72 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option73 = witTypes.Some[golem_core_types.NumericBound](variant72)
+							default:
+								panic("unreachable")
+							}
+							var option75 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option75 = witTypes.None[string]()
+							case 1:
+								value74 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option75 = witTypes.Some[string](value74)
+							default:
+								panic("unreachable")
+							}
+
+							option76 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option71, option73, option75})
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyU16Type(option76)
+
+					case 8:
+						var option83 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option83 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option78 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option78 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant77 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant77 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant77 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant77 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option78 = witTypes.Some[golem_core_types.NumericBound](variant77)
+							default:
+								panic("unreachable")
+							}
+							var option80 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option80 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant79 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant79 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant79 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant79 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option80 = witTypes.Some[golem_core_types.NumericBound](variant79)
+							default:
+								panic("unreachable")
+							}
+							var option82 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option82 = witTypes.None[string]()
+							case 1:
+								value81 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option82 = witTypes.Some[string](value81)
+							default:
+								panic("unreachable")
+							}
+
+							option83 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option78, option80, option82})
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyU32Type(option83)
+
+					case 9:
+						var option90 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option90 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option85 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option85 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant84 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant84 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant84 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant84 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option85 = witTypes.Some[golem_core_types.NumericBound](variant84)
+							default:
+								panic("unreachable")
+							}
+							var option87 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option87 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant86 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant86 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant86 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant86 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option87 = witTypes.Some[golem_core_types.NumericBound](variant86)
+							default:
+								panic("unreachable")
+							}
+							var option89 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option89 = witTypes.None[string]()
+							case 1:
+								value88 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option89 = witTypes.Some[string](value88)
+							default:
+								panic("unreachable")
+							}
+
+							option90 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option85, option87, option89})
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyU64Type(option90)
+
+					case 10:
+						var option97 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option97 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option92 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option92 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant91 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant91 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant91 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant91 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option92 = witTypes.Some[golem_core_types.NumericBound](variant91)
+							default:
+								panic("unreachable")
+							}
+							var option94 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option94 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant93 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant93 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant93 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant93 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option94 = witTypes.Some[golem_core_types.NumericBound](variant93)
+							default:
+								panic("unreachable")
+							}
+							var option96 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option96 = witTypes.None[string]()
+							case 1:
+								value95 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option96 = witTypes.Some[string](value95)
+							default:
+								panic("unreachable")
+							}
+
+							option97 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option92, option94, option96})
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyF32Type(option97)
+
+					case 11:
+						var option104 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option104 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option99 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option99 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant98 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant98 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant98 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant98 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option99 = witTypes.Some[golem_core_types.NumericBound](variant98)
+							default:
+								panic("unreachable")
+							}
+							var option101 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option101 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant100 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant100 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant100 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant100 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option101 = witTypes.Some[golem_core_types.NumericBound](variant100)
+							default:
+								panic("unreachable")
+							}
+							var option103 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option103 = witTypes.None[string]()
+							case 1:
+								value102 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option103 = witTypes.Some[string](value102)
+							default:
+								panic("unreachable")
+							}
+
+							option104 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option99, option101, option103})
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyF64Type(option104)
+
+					case 12:
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+					case 13:
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+					case 14:
+						result117 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+							value105 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var option107 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+							case 0:
+
+								option107 = witTypes.None[string]()
+							case 1:
+								value106 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								option107 = witTypes.Some[string](value106)
+							default:
+								panic("unreachable")
+							}
+							result109 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+								value108 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result109 = append(result109, value108)
+							}
+
+							result111 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+								value110 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result111 = append(result111, value110)
+							}
+
+							var option113 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+							case 0:
+
+								option113 = witTypes.None[string]()
+							case 1:
+								value112 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+								option113 = witTypes.Some[string](value112)
+							default:
+								panic("unreachable")
+							}
+							var option116 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+							case 0:
+
+								option116 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant115 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+								case 0:
+
+									variant115 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant115 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant115 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value114 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+									variant115 = golem_core_types.MakeRoleOther(value114)
+
+								default:
+									panic("unreachable")
+								}
+
+								option116 = witTypes.Some[golem_core_types.Role](variant115)
+							default:
+								panic("unreachable")
+							}
+
+							result117 = append(result117, golem_core_types.NamedFieldType{value105, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option107, result109, result111, option113, option116}})
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyRecordType(result117)
+
+					case 15:
+						result131 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+							value118 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var option119 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+							case 0:
+
+								option119 = witTypes.None[int32]()
+							case 1:
+
+								option119 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+							default:
+								panic("unreachable")
+							}
+							var option121 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option121 = witTypes.None[string]()
+							case 1:
+								value120 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option121 = witTypes.Some[string](value120)
+							default:
+								panic("unreachable")
+							}
+							result123 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+								value122 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result123 = append(result123, value122)
+							}
+
+							result125 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+								value124 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result125 = append(result125, value124)
+							}
+
+							var option127 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+							case 0:
+
+								option127 = witTypes.None[string]()
+							case 1:
+								value126 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+								option127 = witTypes.Some[string](value126)
+							default:
+								panic("unreachable")
+							}
+							var option130 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+							case 0:
+
+								option130 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant129 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+								case 0:
+
+									variant129 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant129 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant129 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value128 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+									variant129 = golem_core_types.MakeRoleOther(value128)
+
+								default:
+									panic("unreachable")
+								}
+
+								option130 = witTypes.Some[golem_core_types.Role](variant129)
+							default:
+								panic("unreachable")
+							}
+
+							result131 = append(result131, golem_core_types.VariantCaseType{value118, option119, golem_core_types.MetadataEnvelope{option121, result123, result125, option127, option130}})
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyVariantType(result131)
+
+					case 16:
+						result133 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+							value132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result133 = append(result133, value132)
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyEnumType(result133)
+
+					case 17:
+						result135 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+							value134 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result135 = append(result135, value134)
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyFlagsType(result135)
+
+					case 18:
+						result136 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result136 = append(result136, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyTupleType(result136)
+
+					case 19:
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 20:
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+					case 21:
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 22:
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 23:
+						var option137 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option137 = witTypes.None[int32]()
+						case 1:
+
+							option137 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+						var option138 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option138 = witTypes.None[int32]()
+						case 1:
+
+							option138 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option137, option138})
+
+					case 24:
+						var option141 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option141 = witTypes.None[[]string]()
+						case 1:
+							result140 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value139 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result140 = append(result140, value139)
+							}
+
+							option141 = witTypes.Some[[]string](result140)
+						default:
+							panic("unreachable")
+						}
+						var option142 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option142 = witTypes.None[uint32]()
+						case 1:
+
+							option142 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option143 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+						case 0:
+
+							option143 = witTypes.None[uint32]()
+						case 1:
+
+							option143 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option145 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+						case 0:
+
+							option145 = witTypes.None[string]()
+						case 1:
+							value144 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+							option145 = witTypes.Some[string](value144)
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option141, option142, option143, option145})
+
+					case 25:
+						var option148 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option148 = witTypes.None[[]string]()
+						case 1:
+							result147 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result147 = append(result147, value146)
+							}
+
+							option148 = witTypes.Some[[]string](result147)
+						default:
+							panic("unreachable")
+						}
+						var option149 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option149 = witTypes.None[uint32]()
+						case 1:
+
+							option149 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option150 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+						case 0:
+
+							option150 = witTypes.None[uint32]()
+						case 1:
+
+							option150 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option148, option149, option150})
+
+					case 26:
+						var option153 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+						case 0:
+
+							option153 = witTypes.None[[]string]()
+						case 1:
+							result152 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value151 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result152 = append(result152, value151)
+							}
+
+							option153 = witTypes.Some[[]string](result152)
+						default:
+							panic("unreachable")
+						}
+						var option156 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+						case 0:
+
+							option156 = witTypes.None[[]string]()
+						case 1:
+							result155 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+								value154 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result155 = append(result155, value154)
+							}
+
+							option156 = witTypes.Some[[]string](result155)
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option153, option156})
+
+					case 27:
+						var option159 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option159 = witTypes.None[[]string]()
+						case 1:
+							result158 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value157 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result158 = append(result158, value157)
+							}
+
+							option159 = witTypes.Some[[]string](result158)
+						default:
+							panic("unreachable")
+						}
+						var option162 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option162 = witTypes.None[[]string]()
+						case 1:
+							result161 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+								value160 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result161 = append(result161, value160)
+							}
+
+							option162 = witTypes.Some[[]string](result161)
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option159, option162})
+
+					case 28:
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+					case 29:
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+					case 30:
+						value163 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						result165 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+							value164 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result165 = append(result165, value164)
+						}
+
+						var option167 witTypes.Option[golem_core_types.QuantityValue]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+						case 0:
+
+							option167 = witTypes.None[golem_core_types.QuantityValue]()
+						case 1:
+							value166 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+							option167 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value166})
+						default:
+							panic("unreachable")
+						}
+						var option169 witTypes.Option[golem_core_types.QuantityValue]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+						case 0:
+
+							option169 = witTypes.None[golem_core_types.QuantityValue]()
+						case 1:
+							value168 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+							option169 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value168})
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value163, result165, option167, option169})
+
+					case 31:
+						result191 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+							value170 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var variant179 golem_core_types.DiscriminatorRule
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+							case 0:
+								value171 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant179 = golem_core_types.MakeDiscriminatorRulePrefix(value171)
+
+							case 1:
+								value172 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant179 = golem_core_types.MakeDiscriminatorRuleSuffix(value172)
+
+							case 2:
+								value173 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant179 = golem_core_types.MakeDiscriminatorRuleContains(value173)
+
+							case 3:
+								value174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant179 = golem_core_types.MakeDiscriminatorRuleRegex(value174)
+
+							case 4:
+								value175 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+								var option177 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+								case 0:
+
+									option177 = witTypes.None[string]()
+								case 1:
+									value176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+									option177 = witTypes.Some[string](value176)
+								default:
+									panic("unreachable")
+								}
+
+								variant179 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value175, option177})
+
+							case 5:
+								value178 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant179 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value178)
+
+							default:
+								panic("unreachable")
+							}
+							var option181 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+							case 0:
+
+								option181 = witTypes.None[string]()
+							case 1:
+								value180 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+								option181 = witTypes.Some[string](value180)
+							default:
+								panic("unreachable")
+							}
+							result183 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+								value182 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result183 = append(result183, value182)
+							}
+
+							result185 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+								value184 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result185 = append(result185, value184)
+							}
+
+							var option187 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+							case 0:
+
+								option187 = witTypes.None[string]()
+							case 1:
+								value186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+								option187 = witTypes.Some[string](value186)
+							default:
+								panic("unreachable")
+							}
+							var option190 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+							case 0:
+
+								option190 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant189 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+								case 0:
+
+									variant189 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant189 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant189 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value188 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+									variant189 = golem_core_types.MakeRoleOther(value188)
+
+								default:
+									panic("unreachable")
+								}
+
+								option190 = witTypes.Some[golem_core_types.Role](variant189)
+							default:
+								panic("unreachable")
+							}
+
+							result191 = append(result191, golem_core_types.UnionBranch{value170, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant179, golem_core_types.MetadataEnvelope{option181, result183, result185, option187, option190}})
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result191})
+
+					case 32:
+						var option193 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+						case 0:
+
+							option193 = witTypes.None[string]()
+						case 1:
+							value192 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+							option193 = witTypes.Some[string](value192)
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option193})
+
+					case 33:
+						var option195 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option195 = witTypes.None[string]()
+						case 1:
+							value194 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+							option195 = witTypes.Some[string](value194)
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option195})
+
+					case 34:
+						var option196 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option196 = witTypes.None[int32]()
+						case 1:
+
+							option196 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyFutureType(option196)
+
+					case 35:
+						var option197 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option197 = witTypes.None[int32]()
+						case 1:
+
+							option197 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant198 = golem_core_types.MakeSchemaTypeBodyStreamType(option197)
+
+					default:
+						panic("unreachable")
+					}
+					var option200 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+					case 0:
+
+						option200 = witTypes.None[string]()
+					case 1:
+						value199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+						option200 = witTypes.Some[string](value199)
+					default:
+						panic("unreachable")
+					}
+					result202 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+						value201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result202 = append(result202, value201)
+					}
+
+					result204 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+						value203 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result204 = append(result204, value203)
+					}
+
+					var option206 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+					case 0:
+
+						option206 = witTypes.None[string]()
+					case 1:
+						value205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+						option206 = witTypes.Some[string](value205)
+					default:
+						panic("unreachable")
+					}
+					var option209 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+					case 0:
+
+						option209 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant208 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+						case 0:
+
+							variant208 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant208 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant208 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value207 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+							variant208 = golem_core_types.MakeRoleOther(value207)
+
+						default:
+							panic("unreachable")
+						}
+
+						option209 = witTypes.Some[golem_core_types.Role](variant208)
+					default:
+						panic("unreachable")
+					}
+
+					result210 = append(result210, golem_core_types.SchemaTypeNode{variant198, golem_core_types.MetadataEnvelope{option200, result202, result204, option206, option209}})
+				}
+
+				result214 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (6 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (6 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4))))), index*(6*4))
+					value211 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var option213 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+
+						option213 = witTypes.None[string]()
+					case 1:
+						value212 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+						option213 = witTypes.Some[string](value212)
+					default:
+						panic("unreachable")
+					}
+
+					result214 = append(result214, golem_core_types.SchemaTypeDef{value211, option213, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+				}
+
+				result238 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (9 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (9 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 * 4))))), index*(16+4*4))
+					var variant237 golem_core_types.SchemaValueNode
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+					case 1:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 2:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 3:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 4:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 5:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 6:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 7:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 8:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 9:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 10:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 11:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 12:
+						value215 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant237 = golem_core_types.MakeSchemaValueNodeStringValue(value215)
+
+					case 13:
+						result216 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result216 = append(result216, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant237 = golem_core_types.MakeSchemaValueNodeRecordValue(result216)
+
+					case 14:
+						var option217 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+						case 0:
+
+							option217 = witTypes.None[int32]()
+						case 1:
+
+							option217 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+						default:
+							panic("unreachable")
+						}
+
+						variant237 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option217})
+
+					case 15:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 16:
+						result218 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+							result218 = append(result218, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+						}
+
+						variant237 = golem_core_types.MakeSchemaValueNodeFlagsValue(result218)
+
+					case 17:
+						result219 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result219 = append(result219, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant237 = golem_core_types.MakeSchemaValueNodeTupleValue(result219)
+
+					case 18:
+						result220 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result220 = append(result220, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant237 = golem_core_types.MakeSchemaValueNodeListValue(result220)
+
+					case 19:
+						result221 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result221 = append(result221, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant237 = golem_core_types.MakeSchemaValueNodeFixedListValue(result221)
+
+					case 20:
+						result222 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+							result222 = append(result222, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+						}
+
+						variant237 = golem_core_types.MakeSchemaValueNodeMapValue(result222)
+
+					case 21:
+						var option223 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option223 = witTypes.None[int32]()
+						case 1:
+
+							option223 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant237 = golem_core_types.MakeSchemaValueNodeOptionValue(option223)
+
+					case 22:
+						var variant226 golem_core_types.ResultValuePayload
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+							var option224 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option224 = witTypes.None[int32]()
+							case 1:
+
+								option224 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant226 = golem_core_types.MakeResultValuePayloadOkValue(option224)
+
+						case 1:
+							var option225 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option225 = witTypes.None[int32]()
+							case 1:
+
+								option225 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant226 = golem_core_types.MakeResultValuePayloadErrValue(option225)
+
+						default:
+							panic("unreachable")
+						}
+
+						variant237 = golem_core_types.MakeSchemaValueNodeResultValue(variant226)
+
+					case 23:
+						value227 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var option229 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option229 = witTypes.None[string]()
+						case 1:
+							value228 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option229 = witTypes.Some[string](value228)
+						default:
+							panic("unreachable")
+						}
+
+						variant237 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value227, option229})
+
+					case 24:
+						value230 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var option232 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option232 = witTypes.None[string]()
+						case 1:
+							value231 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option232 = witTypes.Some[string](value231)
+						default:
+							panic("unreachable")
+						}
+
+						variant237 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value230, option232})
+
+					case 25:
+						value233 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant237 = golem_core_types.MakeSchemaValueNodePathValue(value233)
+
+					case 26:
+						value234 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant237 = golem_core_types.MakeSchemaValueNodeUrlValue(value234)
+
+					case 27:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+					case 28:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+					case 29:
+						value235 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						variant237 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value235})
+
+					case 30:
+						value236 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant237 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value236, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+					case 31:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+					case 32:
+
+						variant237 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+					default:
+						panic("unreachable")
+					}
+
+					result238 = append(result238, variant237)
+				}
+
+				variant239 = golem_agent_common.MakeAgentErrorCustomError(golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result210, result214, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (7 * 4)))}, golem_core_types.SchemaValueTree{result238, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (10 * 4)))}})
+
+			default:
+				panic("unreachable")
+			}
+
+			variant240 = MakeRpcErrorRemoteAgentError(variant239)
+
+		default:
+			panic("unreachable")
+		}
+
+		result241 = witTypes.Err[InvocationMetadata, RpcError](variant240)
+	default:
+		panic("unreachable")
+	}
+	result242 := result241
+	return result242
+
+}
+
+//go:wasmimport golem:agent/host@2.0.0 [method]wasm-rpc.async-invoke-and-await
+func wasm_import_method_wasm_rpc_async_invoke_and_await(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 int32, arg6 uintptr)
+
+func (self *WasmRpc) AsyncInvokeAndAwait(methodName string, input golem_core_types.SchemaValueTree) AsyncInvocationWithMetadata {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(methodName))
+	pinner.Pin(utf8)
+	slice25 := (input).ValueNodes
+	length27 := uint32(len(slice25))
+	result26 := witRuntime.Allocate(pinner, uintptr(length27*(16+4*4)), 8)
+	for index, element := range slice25 {
+		base := unsafe.Add(result26, index*(16+4*4))
+
+		switch element.Tag() {
+		case golem_core_types.SchemaValueNodeBoolValue:
+			payload := element.BoolValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case golem_core_types.SchemaValueNodeS8Value:
+			payload := element.S8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS16Value:
+			payload := element.S16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS32Value:
+			payload := element.S32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeS64Value:
+			payload := element.S64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeU8Value:
+			payload := element.U8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU16Value:
+			payload := element.U16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU32Value:
+			payload := element.U32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeU64Value:
+			payload := element.U64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case golem_core_types.SchemaValueNodeF32Value:
+			payload := element.F32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeF64Value:
+			payload := element.F64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeCharValue:
+			payload := element.CharValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeStringValue:
+			payload := element.StringValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case golem_core_types.SchemaValueNodeRecordValue:
+			payload := element.RecordValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			slice := payload
+			length := uint32(len(slice))
+			result1 := witRuntime.Allocate(pinner, uintptr(length*4), 4)
+			for index, element := range slice {
+				base := unsafe.Add(result1, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result1)))
+
+		case golem_core_types.SchemaValueNodeVariantValue:
+			payload := element.VariantValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).Case)
+
+			switch (payload).Payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeEnumValue:
+			payload := element.EnumValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeFlagsValue:
+			payload := element.FlagsValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			slice3 := payload
+			length5 := uint32(len(slice3))
+			result4 := witRuntime.Allocate(pinner, uintptr(length5*1), 1)
+			for index, element := range slice3 {
+				base := unsafe.Add(result4, index*1)
+				var result2 int32
+				if element {
+					result2 = 1
+				} else {
+					result2 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result2)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length5)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result4)))
+
+		case golem_core_types.SchemaValueNodeTupleValue:
+			payload := element.TupleValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			slice6 := payload
+			length8 := uint32(len(slice6))
+			result7 := witRuntime.Allocate(pinner, uintptr(length8*4), 4)
+			for index, element := range slice6 {
+				base := unsafe.Add(result7, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length8)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result7)))
+
+		case golem_core_types.SchemaValueNodeListValue:
+			payload := element.ListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			slice9 := payload
+			length11 := uint32(len(slice9))
+			result10 := witRuntime.Allocate(pinner, uintptr(length11*4), 4)
+			for index, element := range slice9 {
+				base := unsafe.Add(result10, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length11)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result10)))
+
+		case golem_core_types.SchemaValueNodeFixedListValue:
+			payload := element.FixedListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			slice12 := payload
+			length14 := uint32(len(slice12))
+			result13 := witRuntime.Allocate(pinner, uintptr(length14*4), 4)
+			for index, element := range slice12 {
+				base := unsafe.Add(result13, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length14)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result13)))
+
+		case golem_core_types.SchemaValueNodeMapValue:
+			payload := element.MapValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			slice15 := payload
+			length17 := uint32(len(slice15))
+			result16 := witRuntime.Allocate(pinner, uintptr(length17*8), 4)
+			for index, element := range slice15 {
+				base := unsafe.Add(result16, index*8)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).Key
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (element).Value
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length17)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result16)))
+
+		case golem_core_types.SchemaValueNodeOptionValue:
+			payload := element.OptionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeResultValue:
+			payload := element.ResultValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+
+			switch payload.Tag() {
+			case golem_core_types.ResultValuePayloadOkValue:
+				payload := payload.OkValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.ResultValuePayloadErrValue:
+				payload := payload.ErrValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeTextValue:
+			payload := element.TextValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+			utf818 := unsafe.Pointer(unsafe.StringData((payload).Text))
+			pinner.Pin(utf818)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf818)))
+
+			switch (payload).Language.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Language.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf819 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf819)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf819)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeBinaryValue:
+			payload := element.BinaryValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+			data := unsafe.Pointer(unsafe.SliceData((payload).Bytes))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+			switch (payload).MimeType.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MimeType.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf820 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf820)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf820)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodePathValue:
+			payload := element.PathValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			utf821 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf821)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf821)))
+
+		case golem_core_types.SchemaValueNodeUrlValue:
+			payload := element.UrlValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			utf822 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf822)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf822)))
+
+		case golem_core_types.SchemaValueNodeDatetimeValue:
+			payload := element.DatetimeValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = int32((payload).Nanoseconds)
+
+		case golem_core_types.SchemaValueNodeDurationValue:
+			payload := element.DurationValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Nanoseconds
+
+		case golem_core_types.SchemaValueNodeQuantityValueNode:
+			payload := element.QuantityValueNode()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Mantissa
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Scale
+			utf823 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+			pinner.Pin(utf823)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uint32(len((payload).Unit)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))) = uint32(uintptr(uintptr(utf823)))
+
+		case golem_core_types.SchemaValueNodeUnionValue:
+			payload := element.UnionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			utf824 := unsafe.Pointer(unsafe.StringData((payload).Tag))
+			pinner.Pin(utf824)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf824)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Body
+
+		case golem_core_types.SchemaValueNodeSecretValue:
+			payload := element.SecretValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		case golem_core_types.SchemaValueNodeQuotaTokenHandle:
+			payload := element.QuotaTokenHandle()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_wasm_rpc_async_invoke_and_await((self).Handle(), uintptr(utf8), uint32(len(methodName)), uintptr(result26), length27, (input).Root, returnArea)
+	value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+	result29 := AsyncInvocationWithMetadata{InvocationMetadata{value, value28}, FutureInvokeResultFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))))}
+	return result29
+
+}
+
+//go:wasmimport golem:agent/host@2.0.0 [method]wasm-rpc.schedule-invocation
+func wasm_import_method_wasm_rpc_schedule_invocation(arg0 int32, arg1 int64, arg2 int32, arg3 uintptr, arg4 uint32, arg5 uintptr, arg6 uint32, arg7 int32, arg8 uintptr)
+
+func (self *WasmRpc) ScheduleInvocation(scheduledTime wasi_clocks_0_3_0_system_clock.Instant, methodName string, input golem_core_types.SchemaValueTree) ScheduledInvocationReceipt {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(methodName))
+	pinner.Pin(utf8)
+	slice25 := (input).ValueNodes
+	length27 := uint32(len(slice25))
+	result26 := witRuntime.Allocate(pinner, uintptr(length27*(16+4*4)), 8)
+	for index, element := range slice25 {
+		base := unsafe.Add(result26, index*(16+4*4))
+
+		switch element.Tag() {
+		case golem_core_types.SchemaValueNodeBoolValue:
+			payload := element.BoolValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case golem_core_types.SchemaValueNodeS8Value:
+			payload := element.S8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS16Value:
+			payload := element.S16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS32Value:
+			payload := element.S32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeS64Value:
+			payload := element.S64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeU8Value:
+			payload := element.U8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU16Value:
+			payload := element.U16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU32Value:
+			payload := element.U32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeU64Value:
+			payload := element.U64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case golem_core_types.SchemaValueNodeF32Value:
+			payload := element.F32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeF64Value:
+			payload := element.F64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeCharValue:
+			payload := element.CharValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeStringValue:
+			payload := element.StringValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case golem_core_types.SchemaValueNodeRecordValue:
+			payload := element.RecordValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			slice := payload
+			length := uint32(len(slice))
+			result1 := witRuntime.Allocate(pinner, uintptr(length*4), 4)
+			for index, element := range slice {
+				base := unsafe.Add(result1, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result1)))
+
+		case golem_core_types.SchemaValueNodeVariantValue:
+			payload := element.VariantValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).Case)
+
+			switch (payload).Payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeEnumValue:
+			payload := element.EnumValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeFlagsValue:
+			payload := element.FlagsValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			slice3 := payload
+			length5 := uint32(len(slice3))
+			result4 := witRuntime.Allocate(pinner, uintptr(length5*1), 1)
+			for index, element := range slice3 {
+				base := unsafe.Add(result4, index*1)
+				var result2 int32
+				if element {
+					result2 = 1
+				} else {
+					result2 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result2)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length5)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result4)))
+
+		case golem_core_types.SchemaValueNodeTupleValue:
+			payload := element.TupleValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			slice6 := payload
+			length8 := uint32(len(slice6))
+			result7 := witRuntime.Allocate(pinner, uintptr(length8*4), 4)
+			for index, element := range slice6 {
+				base := unsafe.Add(result7, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length8)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result7)))
+
+		case golem_core_types.SchemaValueNodeListValue:
+			payload := element.ListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			slice9 := payload
+			length11 := uint32(len(slice9))
+			result10 := witRuntime.Allocate(pinner, uintptr(length11*4), 4)
+			for index, element := range slice9 {
+				base := unsafe.Add(result10, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length11)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result10)))
+
+		case golem_core_types.SchemaValueNodeFixedListValue:
+			payload := element.FixedListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			slice12 := payload
+			length14 := uint32(len(slice12))
+			result13 := witRuntime.Allocate(pinner, uintptr(length14*4), 4)
+			for index, element := range slice12 {
+				base := unsafe.Add(result13, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length14)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result13)))
+
+		case golem_core_types.SchemaValueNodeMapValue:
+			payload := element.MapValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			slice15 := payload
+			length17 := uint32(len(slice15))
+			result16 := witRuntime.Allocate(pinner, uintptr(length17*8), 4)
+			for index, element := range slice15 {
+				base := unsafe.Add(result16, index*8)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).Key
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (element).Value
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length17)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result16)))
+
+		case golem_core_types.SchemaValueNodeOptionValue:
+			payload := element.OptionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeResultValue:
+			payload := element.ResultValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+
+			switch payload.Tag() {
+			case golem_core_types.ResultValuePayloadOkValue:
+				payload := payload.OkValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.ResultValuePayloadErrValue:
+				payload := payload.ErrValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeTextValue:
+			payload := element.TextValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+			utf818 := unsafe.Pointer(unsafe.StringData((payload).Text))
+			pinner.Pin(utf818)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf818)))
+
+			switch (payload).Language.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Language.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf819 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf819)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf819)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeBinaryValue:
+			payload := element.BinaryValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+			data := unsafe.Pointer(unsafe.SliceData((payload).Bytes))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+			switch (payload).MimeType.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MimeType.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf820 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf820)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf820)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodePathValue:
+			payload := element.PathValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			utf821 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf821)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf821)))
+
+		case golem_core_types.SchemaValueNodeUrlValue:
+			payload := element.UrlValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			utf822 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf822)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf822)))
+
+		case golem_core_types.SchemaValueNodeDatetimeValue:
+			payload := element.DatetimeValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = int32((payload).Nanoseconds)
+
+		case golem_core_types.SchemaValueNodeDurationValue:
+			payload := element.DurationValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Nanoseconds
+
+		case golem_core_types.SchemaValueNodeQuantityValueNode:
+			payload := element.QuantityValueNode()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Mantissa
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Scale
+			utf823 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+			pinner.Pin(utf823)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uint32(len((payload).Unit)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))) = uint32(uintptr(uintptr(utf823)))
+
+		case golem_core_types.SchemaValueNodeUnionValue:
+			payload := element.UnionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			utf824 := unsafe.Pointer(unsafe.StringData((payload).Tag))
+			pinner.Pin(utf824)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf824)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Body
+
+		case golem_core_types.SchemaValueNodeSecretValue:
+			payload := element.SecretValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		case golem_core_types.SchemaValueNodeQuotaTokenHandle:
+			payload := element.QuotaTokenHandle()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_wasm_rpc_schedule_invocation((self).Handle(), (scheduledTime).Seconds, int32((scheduledTime).Nanoseconds), uintptr(utf8), uint32(len(methodName)), uintptr(result26), length27, (input).Root, returnArea)
+	value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+	result29 := ScheduledInvocationReceipt{InvocationMetadata{value, value28}}
+	return result29
+
+}
+
+//go:wasmimport golem:agent/host@2.0.0 [method]wasm-rpc.schedule-cancelable-invocation
+func wasm_import_method_wasm_rpc_schedule_cancelable_invocation(arg0 int32, arg1 int64, arg2 int32, arg3 uintptr, arg4 uint32, arg5 uintptr, arg6 uint32, arg7 int32, arg8 uintptr)
+
+func (self *WasmRpc) ScheduleCancelableInvocation(scheduledTime wasi_clocks_0_3_0_system_clock.Instant, methodName string, input golem_core_types.SchemaValueTree) CancelableScheduledInvocationReceipt {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(methodName))
+	pinner.Pin(utf8)
+	slice25 := (input).ValueNodes
+	length27 := uint32(len(slice25))
+	result26 := witRuntime.Allocate(pinner, uintptr(length27*(16+4*4)), 8)
+	for index, element := range slice25 {
+		base := unsafe.Add(result26, index*(16+4*4))
+
+		switch element.Tag() {
+		case golem_core_types.SchemaValueNodeBoolValue:
+			payload := element.BoolValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case golem_core_types.SchemaValueNodeS8Value:
+			payload := element.S8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS16Value:
+			payload := element.S16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS32Value:
+			payload := element.S32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeS64Value:
+			payload := element.S64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeU8Value:
+			payload := element.U8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU16Value:
+			payload := element.U16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU32Value:
+			payload := element.U32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeU64Value:
+			payload := element.U64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case golem_core_types.SchemaValueNodeF32Value:
+			payload := element.F32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeF64Value:
+			payload := element.F64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeCharValue:
+			payload := element.CharValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeStringValue:
+			payload := element.StringValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case golem_core_types.SchemaValueNodeRecordValue:
+			payload := element.RecordValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			slice := payload
+			length := uint32(len(slice))
+			result1 := witRuntime.Allocate(pinner, uintptr(length*4), 4)
+			for index, element := range slice {
+				base := unsafe.Add(result1, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result1)))
+
+		case golem_core_types.SchemaValueNodeVariantValue:
+			payload := element.VariantValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).Case)
+
+			switch (payload).Payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeEnumValue:
+			payload := element.EnumValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeFlagsValue:
+			payload := element.FlagsValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			slice3 := payload
+			length5 := uint32(len(slice3))
+			result4 := witRuntime.Allocate(pinner, uintptr(length5*1), 1)
+			for index, element := range slice3 {
+				base := unsafe.Add(result4, index*1)
+				var result2 int32
+				if element {
+					result2 = 1
+				} else {
+					result2 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result2)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length5)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result4)))
+
+		case golem_core_types.SchemaValueNodeTupleValue:
+			payload := element.TupleValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			slice6 := payload
+			length8 := uint32(len(slice6))
+			result7 := witRuntime.Allocate(pinner, uintptr(length8*4), 4)
+			for index, element := range slice6 {
+				base := unsafe.Add(result7, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length8)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result7)))
+
+		case golem_core_types.SchemaValueNodeListValue:
+			payload := element.ListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			slice9 := payload
+			length11 := uint32(len(slice9))
+			result10 := witRuntime.Allocate(pinner, uintptr(length11*4), 4)
+			for index, element := range slice9 {
+				base := unsafe.Add(result10, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length11)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result10)))
+
+		case golem_core_types.SchemaValueNodeFixedListValue:
+			payload := element.FixedListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			slice12 := payload
+			length14 := uint32(len(slice12))
+			result13 := witRuntime.Allocate(pinner, uintptr(length14*4), 4)
+			for index, element := range slice12 {
+				base := unsafe.Add(result13, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length14)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result13)))
+
+		case golem_core_types.SchemaValueNodeMapValue:
+			payload := element.MapValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			slice15 := payload
+			length17 := uint32(len(slice15))
+			result16 := witRuntime.Allocate(pinner, uintptr(length17*8), 4)
+			for index, element := range slice15 {
+				base := unsafe.Add(result16, index*8)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).Key
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (element).Value
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length17)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result16)))
+
+		case golem_core_types.SchemaValueNodeOptionValue:
+			payload := element.OptionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeResultValue:
+			payload := element.ResultValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+
+			switch payload.Tag() {
+			case golem_core_types.ResultValuePayloadOkValue:
+				payload := payload.OkValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.ResultValuePayloadErrValue:
+				payload := payload.ErrValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeTextValue:
+			payload := element.TextValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+			utf818 := unsafe.Pointer(unsafe.StringData((payload).Text))
+			pinner.Pin(utf818)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf818)))
+
+			switch (payload).Language.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Language.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf819 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf819)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf819)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeBinaryValue:
+			payload := element.BinaryValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+			data := unsafe.Pointer(unsafe.SliceData((payload).Bytes))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+			switch (payload).MimeType.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MimeType.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf820 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf820)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf820)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodePathValue:
+			payload := element.PathValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			utf821 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf821)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf821)))
+
+		case golem_core_types.SchemaValueNodeUrlValue:
+			payload := element.UrlValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			utf822 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf822)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf822)))
+
+		case golem_core_types.SchemaValueNodeDatetimeValue:
+			payload := element.DatetimeValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = int32((payload).Nanoseconds)
+
+		case golem_core_types.SchemaValueNodeDurationValue:
+			payload := element.DurationValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Nanoseconds
+
+		case golem_core_types.SchemaValueNodeQuantityValueNode:
+			payload := element.QuantityValueNode()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Mantissa
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Scale
+			utf823 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+			pinner.Pin(utf823)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uint32(len((payload).Unit)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))) = uint32(uintptr(uintptr(utf823)))
+
+		case golem_core_types.SchemaValueNodeUnionValue:
+			payload := element.UnionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			utf824 := unsafe.Pointer(unsafe.StringData((payload).Tag))
+			pinner.Pin(utf824)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf824)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Body
+
+		case golem_core_types.SchemaValueNodeSecretValue:
+			payload := element.SecretValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		case golem_core_types.SchemaValueNodeQuotaTokenHandle:
+			payload := element.QuotaTokenHandle()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_wasm_rpc_schedule_cancelable_invocation((self).Handle(), (scheduledTime).Seconds, int32((scheduledTime).Nanoseconds), uintptr(utf8), uint32(len(methodName)), uintptr(result26), length27, (input).Root, returnArea)
+	value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+	result29 := CancelableScheduledInvocationReceipt{InvocationMetadata{value, value28}, CancellationTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))))}
+	return result29
+
+}
+
+//go:wasmimport golem:agent/host@2.0.0 [async-lower][method]future-invoke-result.get
+func wasm_import_method_future_invoke_result_get(arg0 int32, arg1 uintptr) int32
+
+func (self *FutureInvokeResult) Get() witTypes.Result[witTypes.Option[golem_core_types.SchemaValueTree], RpcError] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (11 * 4), 4))
+
+	witAsync.SubtaskWait(uint32(wasm_import_method_future_invoke_result_get((self).Handle(), returnArea)))
+	var result235 witTypes.Result[witTypes.Option[golem_core_types.SchemaValueTree], RpcError]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		var option20 witTypes.Option[golem_core_types.SchemaValueTree]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+
+			option20 = witTypes.None[golem_core_types.SchemaValueTree]()
+		case 1:
+			result19 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))), index*(16+4*4))
+				var variant18 golem_core_types.SchemaValueNode
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+				case 1:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 2:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 3:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 4:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 5:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 6:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 7:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 8:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 9:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 10:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 11:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 12:
+					value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant18 = golem_core_types.MakeSchemaValueNodeStringValue(value)
+
+				case 13:
+					result := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result = append(result, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant18 = golem_core_types.MakeSchemaValueNodeRecordValue(result)
+
+				case 14:
+					var option witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+					case 0:
+
+						option = witTypes.None[int32]()
+					case 1:
+
+						option = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+					default:
+						panic("unreachable")
+					}
+
+					variant18 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option})
+
+				case 15:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 16:
+					result0 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+						result0 = append(result0, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+					}
+
+					variant18 = golem_core_types.MakeSchemaValueNodeFlagsValue(result0)
+
+				case 17:
+					result1 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result1 = append(result1, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant18 = golem_core_types.MakeSchemaValueNodeTupleValue(result1)
+
+				case 18:
+					result2 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result2 = append(result2, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant18 = golem_core_types.MakeSchemaValueNodeListValue(result2)
+
+				case 19:
+					result3 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result3 = append(result3, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+					}
+
+					variant18 = golem_core_types.MakeSchemaValueNodeFixedListValue(result3)
+
+				case 20:
+					result4 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+						result4 = append(result4, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+					}
+
+					variant18 = golem_core_types.MakeSchemaValueNodeMapValue(result4)
+
+				case 21:
+					var option5 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						option5 = witTypes.None[int32]()
+					case 1:
+
+						option5 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+					default:
+						panic("unreachable")
+					}
+
+					variant18 = golem_core_types.MakeSchemaValueNodeOptionValue(option5)
+
+				case 22:
+					var variant golem_core_types.ResultValuePayload
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+						var option6 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+						case 0:
+
+							option6 = witTypes.None[int32]()
+						case 1:
+
+							option6 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+						default:
+							panic("unreachable")
+						}
+
+						variant = golem_core_types.MakeResultValuePayloadOkValue(option6)
+
+					case 1:
+						var option7 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+						case 0:
+
+							option7 = witTypes.None[int32]()
+						case 1:
+
+							option7 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+						default:
+							panic("unreachable")
+						}
+
+						variant = golem_core_types.MakeResultValuePayloadErrValue(option7)
+
+					default:
+						panic("unreachable")
+					}
+
+					variant18 = golem_core_types.MakeSchemaValueNodeResultValue(variant)
+
+				case 23:
+					value8 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					var option10 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						option10 = witTypes.None[string]()
+					case 1:
+						value9 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+						option10 = witTypes.Some[string](value9)
+					default:
+						panic("unreachable")
+					}
+
+					variant18 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value8, option10})
+
+				case 24:
+					value11 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					var option13 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						option13 = witTypes.None[string]()
+					case 1:
+						value12 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+						option13 = witTypes.Some[string](value12)
+					default:
+						panic("unreachable")
+					}
+
+					variant18 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value11, option13})
+
+				case 25:
+					value14 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant18 = golem_core_types.MakeSchemaValueNodePathValue(value14)
+
+				case 26:
+					value15 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant18 = golem_core_types.MakeSchemaValueNodeUrlValue(value15)
+
+				case 27:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+				case 28:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+				case 29:
+					value16 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+					variant18 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value16})
+
+				case 30:
+					value17 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant18 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value17, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+				case 31:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+				case 32:
+
+					variant18 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+				default:
+					panic("unreachable")
+				}
+
+				result19 = append(result19, variant18)
+			}
+
+			option20 = witTypes.Some[golem_core_types.SchemaValueTree](golem_core_types.SchemaValueTree{result19, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))})
+		default:
+			panic("unreachable")
+		}
+
+		result235 = witTypes.Ok[witTypes.Option[golem_core_types.SchemaValueTree], RpcError](option20)
+	case 1:
+		var variant234 RpcError
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value21 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant234 = MakeRpcErrorProtocolError(value21)
+
+		case 1:
+			value22 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant234 = MakeRpcErrorDenied(value22)
+
+		case 2:
+			value23 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant234 = MakeRpcErrorNotFound(value23)
+
+		case 3:
+			value24 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant234 = MakeRpcErrorRemoteInternalError(value24)
+
+		case 4:
+			var variant233 golem_agent_common.AgentError
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+				value25 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				variant233 = golem_agent_common.MakeAgentErrorInvalidInput(value25)
+
+			case 1:
+				value26 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				variant233 = golem_agent_common.MakeAgentErrorInvalidMethod(value26)
+
+			case 2:
+				value27 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				variant233 = golem_agent_common.MakeAgentErrorInvalidType(value27)
+
+			case 3:
+				value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				variant233 = golem_agent_common.MakeAgentErrorInvalidAgentId(value28)
+
+			case 4:
+				result204 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))), index*(56+22*4))
+					var variant192 golem_core_types.SchemaTypeBody
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 1:
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+					case 2:
+						var option35 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option35 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option30 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option30 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant29 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant29 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant29 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant29 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option30 = witTypes.Some[golem_core_types.NumericBound](variant29)
+							default:
+								panic("unreachable")
+							}
+							var option32 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option32 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant31 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant31 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant31 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant31 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option32 = witTypes.Some[golem_core_types.NumericBound](variant31)
+							default:
+								panic("unreachable")
+							}
+							var option34 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option34 = witTypes.None[string]()
+							case 1:
+								value33 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option34 = witTypes.Some[string](value33)
+							default:
+								panic("unreachable")
+							}
+
+							option35 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option30, option32, option34})
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyS8Type(option35)
+
+					case 3:
+						var option42 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option42 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option37 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option37 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant36 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant36 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant36 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant36 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option37 = witTypes.Some[golem_core_types.NumericBound](variant36)
+							default:
+								panic("unreachable")
+							}
+							var option39 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option39 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant38 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant38 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant38 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant38 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option39 = witTypes.Some[golem_core_types.NumericBound](variant38)
+							default:
+								panic("unreachable")
+							}
+							var option41 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option41 = witTypes.None[string]()
+							case 1:
+								value40 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option41 = witTypes.Some[string](value40)
+							default:
+								panic("unreachable")
+							}
+
+							option42 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option37, option39, option41})
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyS16Type(option42)
+
+					case 4:
+						var option49 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option49 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option44 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option44 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant43 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant43 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant43 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant43 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option44 = witTypes.Some[golem_core_types.NumericBound](variant43)
+							default:
+								panic("unreachable")
+							}
+							var option46 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option46 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant45 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant45 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant45 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant45 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option46 = witTypes.Some[golem_core_types.NumericBound](variant45)
+							default:
+								panic("unreachable")
+							}
+							var option48 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option48 = witTypes.None[string]()
+							case 1:
+								value47 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option48 = witTypes.Some[string](value47)
+							default:
+								panic("unreachable")
+							}
+
+							option49 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option44, option46, option48})
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyS32Type(option49)
+
+					case 5:
+						var option56 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option56 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option51 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option51 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant50 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant50 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant50 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant50 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option51 = witTypes.Some[golem_core_types.NumericBound](variant50)
+							default:
+								panic("unreachable")
+							}
+							var option53 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option53 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant52 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant52 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant52 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant52 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option53 = witTypes.Some[golem_core_types.NumericBound](variant52)
+							default:
+								panic("unreachable")
+							}
+							var option55 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option55 = witTypes.None[string]()
+							case 1:
+								value54 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option55 = witTypes.Some[string](value54)
+							default:
+								panic("unreachable")
+							}
+
+							option56 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option51, option53, option55})
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyS64Type(option56)
+
+					case 6:
+						var option63 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option63 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option58 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option58 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant57 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant57 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant57 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant57 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option58 = witTypes.Some[golem_core_types.NumericBound](variant57)
+							default:
+								panic("unreachable")
+							}
+							var option60 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option60 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant59 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant59 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant59 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant59 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option60 = witTypes.Some[golem_core_types.NumericBound](variant59)
+							default:
+								panic("unreachable")
+							}
+							var option62 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option62 = witTypes.None[string]()
+							case 1:
+								value61 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option62 = witTypes.Some[string](value61)
+							default:
+								panic("unreachable")
+							}
+
+							option63 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option58, option60, option62})
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyU8Type(option63)
+
+					case 7:
+						var option70 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option70 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option65 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option65 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant64 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant64 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant64 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant64 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option65 = witTypes.Some[golem_core_types.NumericBound](variant64)
+							default:
+								panic("unreachable")
+							}
+							var option67 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option67 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant66 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant66 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant66 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant66 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option67 = witTypes.Some[golem_core_types.NumericBound](variant66)
+							default:
+								panic("unreachable")
+							}
+							var option69 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option69 = witTypes.None[string]()
+							case 1:
+								value68 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option69 = witTypes.Some[string](value68)
+							default:
+								panic("unreachable")
+							}
+
+							option70 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option65, option67, option69})
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyU16Type(option70)
+
+					case 8:
+						var option77 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option77 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option72 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option72 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant71 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant71 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant71 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant71 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option72 = witTypes.Some[golem_core_types.NumericBound](variant71)
+							default:
+								panic("unreachable")
+							}
+							var option74 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option74 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant73 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant73 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant73 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant73 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option74 = witTypes.Some[golem_core_types.NumericBound](variant73)
+							default:
+								panic("unreachable")
+							}
+							var option76 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option76 = witTypes.None[string]()
+							case 1:
+								value75 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option76 = witTypes.Some[string](value75)
+							default:
+								panic("unreachable")
+							}
+
+							option77 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option72, option74, option76})
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyU32Type(option77)
+
+					case 9:
+						var option84 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option84 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option79 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option79 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant78 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant78 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant78 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant78 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option79 = witTypes.Some[golem_core_types.NumericBound](variant78)
+							default:
+								panic("unreachable")
+							}
+							var option81 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option81 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant80 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant80 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant80 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant80 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option81 = witTypes.Some[golem_core_types.NumericBound](variant80)
+							default:
+								panic("unreachable")
+							}
+							var option83 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option83 = witTypes.None[string]()
+							case 1:
+								value82 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option83 = witTypes.Some[string](value82)
+							default:
+								panic("unreachable")
+							}
+
+							option84 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option79, option81, option83})
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyU64Type(option84)
+
+					case 10:
+						var option91 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option91 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option86 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option86 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant85 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant85 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant85 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant85 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option86 = witTypes.Some[golem_core_types.NumericBound](variant85)
+							default:
+								panic("unreachable")
+							}
+							var option88 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option88 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant87 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant87 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant87 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant87 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option88 = witTypes.Some[golem_core_types.NumericBound](variant87)
+							default:
+								panic("unreachable")
+							}
+							var option90 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option90 = witTypes.None[string]()
+							case 1:
+								value89 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option90 = witTypes.Some[string](value89)
+							default:
+								panic("unreachable")
+							}
+
+							option91 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option86, option88, option90})
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyF32Type(option91)
+
+					case 11:
+						var option98 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option98 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option93 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option93 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant92 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant92 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant92 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant92 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option93 = witTypes.Some[golem_core_types.NumericBound](variant92)
+							default:
+								panic("unreachable")
+							}
+							var option95 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option95 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant94 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant94 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant94 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant94 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option95 = witTypes.Some[golem_core_types.NumericBound](variant94)
+							default:
+								panic("unreachable")
+							}
+							var option97 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option97 = witTypes.None[string]()
+							case 1:
+								value96 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option97 = witTypes.Some[string](value96)
+							default:
+								panic("unreachable")
+							}
+
+							option98 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option93, option95, option97})
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyF64Type(option98)
+
+					case 12:
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+					case 13:
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+					case 14:
+						result111 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+							value99 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var option101 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+							case 0:
+
+								option101 = witTypes.None[string]()
+							case 1:
+								value100 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								option101 = witTypes.Some[string](value100)
+							default:
+								panic("unreachable")
+							}
+							result103 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+								value102 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result103 = append(result103, value102)
+							}
+
+							result105 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+								value104 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result105 = append(result105, value104)
+							}
+
+							var option107 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+							case 0:
+
+								option107 = witTypes.None[string]()
+							case 1:
+								value106 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+								option107 = witTypes.Some[string](value106)
+							default:
+								panic("unreachable")
+							}
+							var option110 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+							case 0:
+
+								option110 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant109 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+								case 0:
+
+									variant109 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant109 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant109 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value108 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+									variant109 = golem_core_types.MakeRoleOther(value108)
+
+								default:
+									panic("unreachable")
+								}
+
+								option110 = witTypes.Some[golem_core_types.Role](variant109)
+							default:
+								panic("unreachable")
+							}
+
+							result111 = append(result111, golem_core_types.NamedFieldType{value99, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option101, result103, result105, option107, option110}})
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyRecordType(result111)
+
+					case 15:
+						result125 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+							value112 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var option113 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+							case 0:
+
+								option113 = witTypes.None[int32]()
+							case 1:
+
+								option113 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+							default:
+								panic("unreachable")
+							}
+							var option115 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option115 = witTypes.None[string]()
+							case 1:
+								value114 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option115 = witTypes.Some[string](value114)
+							default:
+								panic("unreachable")
+							}
+							result117 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+								value116 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result117 = append(result117, value116)
+							}
+
+							result119 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+								value118 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result119 = append(result119, value118)
+							}
+
+							var option121 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+							case 0:
+
+								option121 = witTypes.None[string]()
+							case 1:
+								value120 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+								option121 = witTypes.Some[string](value120)
+							default:
+								panic("unreachable")
+							}
+							var option124 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+							case 0:
+
+								option124 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant123 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+								case 0:
+
+									variant123 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant123 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant123 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value122 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+									variant123 = golem_core_types.MakeRoleOther(value122)
+
+								default:
+									panic("unreachable")
+								}
+
+								option124 = witTypes.Some[golem_core_types.Role](variant123)
+							default:
+								panic("unreachable")
+							}
+
+							result125 = append(result125, golem_core_types.VariantCaseType{value112, option113, golem_core_types.MetadataEnvelope{option115, result117, result119, option121, option124}})
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyVariantType(result125)
+
+					case 16:
+						result127 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+							value126 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result127 = append(result127, value126)
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyEnumType(result127)
+
+					case 17:
+						result129 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+							value128 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result129 = append(result129, value128)
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyFlagsType(result129)
+
+					case 18:
+						result130 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result130 = append(result130, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyTupleType(result130)
+
+					case 19:
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 20:
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+					case 21:
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 22:
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 23:
+						var option131 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option131 = witTypes.None[int32]()
+						case 1:
+
+							option131 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+						var option132 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option132 = witTypes.None[int32]()
+						case 1:
+
+							option132 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option131, option132})
+
+					case 24:
+						var option135 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option135 = witTypes.None[[]string]()
+						case 1:
+							result134 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value133 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result134 = append(result134, value133)
+							}
+
+							option135 = witTypes.Some[[]string](result134)
+						default:
+							panic("unreachable")
+						}
+						var option136 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option136 = witTypes.None[uint32]()
+						case 1:
+
+							option136 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option137 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+						case 0:
+
+							option137 = witTypes.None[uint32]()
+						case 1:
+
+							option137 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option139 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+						case 0:
+
+							option139 = witTypes.None[string]()
+						case 1:
+							value138 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+							option139 = witTypes.Some[string](value138)
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option135, option136, option137, option139})
+
+					case 25:
+						var option142 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option142 = witTypes.None[[]string]()
+						case 1:
+							result141 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value140 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result141 = append(result141, value140)
+							}
+
+							option142 = witTypes.Some[[]string](result141)
+						default:
+							panic("unreachable")
+						}
+						var option143 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option143 = witTypes.None[uint32]()
+						case 1:
+
+							option143 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option144 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+						case 0:
+
+							option144 = witTypes.None[uint32]()
+						case 1:
+
+							option144 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option142, option143, option144})
+
+					case 26:
+						var option147 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+						case 0:
+
+							option147 = witTypes.None[[]string]()
+						case 1:
+							result146 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value145 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result146 = append(result146, value145)
+							}
+
+							option147 = witTypes.Some[[]string](result146)
+						default:
+							panic("unreachable")
+						}
+						var option150 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+						case 0:
+
+							option150 = witTypes.None[[]string]()
+						case 1:
+							result149 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+								value148 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result149 = append(result149, value148)
+							}
+
+							option150 = witTypes.Some[[]string](result149)
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option147, option150})
+
+					case 27:
+						var option153 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option153 = witTypes.None[[]string]()
+						case 1:
+							result152 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value151 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result152 = append(result152, value151)
+							}
+
+							option153 = witTypes.Some[[]string](result152)
+						default:
+							panic("unreachable")
+						}
+						var option156 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option156 = witTypes.None[[]string]()
+						case 1:
+							result155 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+								value154 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result155 = append(result155, value154)
+							}
+
+							option156 = witTypes.Some[[]string](result155)
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option153, option156})
+
+					case 28:
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+					case 29:
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+					case 30:
+						value157 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						result159 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+							value158 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result159 = append(result159, value158)
+						}
+
+						var option161 witTypes.Option[golem_core_types.QuantityValue]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+						case 0:
+
+							option161 = witTypes.None[golem_core_types.QuantityValue]()
+						case 1:
+							value160 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+							option161 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value160})
+						default:
+							panic("unreachable")
+						}
+						var option163 witTypes.Option[golem_core_types.QuantityValue]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+						case 0:
+
+							option163 = witTypes.None[golem_core_types.QuantityValue]()
+						case 1:
+							value162 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+							option163 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value162})
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value157, result159, option161, option163})
+
+					case 31:
+						result185 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+							value164 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var variant173 golem_core_types.DiscriminatorRule
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+							case 0:
+								value165 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant173 = golem_core_types.MakeDiscriminatorRulePrefix(value165)
+
+							case 1:
+								value166 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant173 = golem_core_types.MakeDiscriminatorRuleSuffix(value166)
+
+							case 2:
+								value167 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant173 = golem_core_types.MakeDiscriminatorRuleContains(value167)
+
+							case 3:
+								value168 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant173 = golem_core_types.MakeDiscriminatorRuleRegex(value168)
+
+							case 4:
+								value169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+								var option171 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+								case 0:
+
+									option171 = witTypes.None[string]()
+								case 1:
+									value170 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+									option171 = witTypes.Some[string](value170)
+								default:
+									panic("unreachable")
+								}
+
+								variant173 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value169, option171})
+
+							case 5:
+								value172 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant173 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value172)
+
+							default:
+								panic("unreachable")
+							}
+							var option175 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+							case 0:
+
+								option175 = witTypes.None[string]()
+							case 1:
+								value174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+								option175 = witTypes.Some[string](value174)
+							default:
+								panic("unreachable")
+							}
+							result177 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+								value176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result177 = append(result177, value176)
+							}
+
+							result179 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+								value178 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result179 = append(result179, value178)
+							}
+
+							var option181 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+							case 0:
+
+								option181 = witTypes.None[string]()
+							case 1:
+								value180 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+								option181 = witTypes.Some[string](value180)
+							default:
+								panic("unreachable")
+							}
+							var option184 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+							case 0:
+
+								option184 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant183 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+								case 0:
+
+									variant183 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant183 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant183 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value182 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+									variant183 = golem_core_types.MakeRoleOther(value182)
+
+								default:
+									panic("unreachable")
+								}
+
+								option184 = witTypes.Some[golem_core_types.Role](variant183)
+							default:
+								panic("unreachable")
+							}
+
+							result185 = append(result185, golem_core_types.UnionBranch{value164, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant173, golem_core_types.MetadataEnvelope{option175, result177, result179, option181, option184}})
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result185})
+
+					case 32:
+						var option187 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+						case 0:
+
+							option187 = witTypes.None[string]()
+						case 1:
+							value186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+							option187 = witTypes.Some[string](value186)
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option187})
+
+					case 33:
+						var option189 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option189 = witTypes.None[string]()
+						case 1:
+							value188 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+							option189 = witTypes.Some[string](value188)
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option189})
+
+					case 34:
+						var option190 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option190 = witTypes.None[int32]()
+						case 1:
+
+							option190 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyFutureType(option190)
+
+					case 35:
+						var option191 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option191 = witTypes.None[int32]()
+						case 1:
+
+							option191 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant192 = golem_core_types.MakeSchemaTypeBodyStreamType(option191)
+
+					default:
+						panic("unreachable")
+					}
+					var option194 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+					case 0:
+
+						option194 = witTypes.None[string]()
+					case 1:
+						value193 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+						option194 = witTypes.Some[string](value193)
+					default:
+						panic("unreachable")
+					}
+					result196 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+						value195 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result196 = append(result196, value195)
+					}
+
+					result198 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+						value197 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result198 = append(result198, value197)
+					}
+
+					var option200 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+					case 0:
+
+						option200 = witTypes.None[string]()
+					case 1:
+						value199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+						option200 = witTypes.Some[string](value199)
+					default:
+						panic("unreachable")
+					}
+					var option203 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+					case 0:
+
+						option203 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant202 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+						case 0:
+
+							variant202 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant202 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant202 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+							variant202 = golem_core_types.MakeRoleOther(value201)
+
+						default:
+							panic("unreachable")
+						}
+
+						option203 = witTypes.Some[golem_core_types.Role](variant202)
+					default:
+						panic("unreachable")
+					}
+
+					result204 = append(result204, golem_core_types.SchemaTypeNode{variant192, golem_core_types.MetadataEnvelope{option194, result196, result198, option200, option203}})
+				}
+
+				result208 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (6 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (6 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4))))), index*(6*4))
+					value205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var option207 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+
+						option207 = witTypes.None[string]()
+					case 1:
+						value206 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+						option207 = witTypes.Some[string](value206)
+					default:
+						panic("unreachable")
+					}
+
+					result208 = append(result208, golem_core_types.SchemaTypeDef{value205, option207, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+				}
+
+				result232 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (9 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (9 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 * 4))))), index*(16+4*4))
+					var variant231 golem_core_types.SchemaValueNode
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+					case 1:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 2:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 3:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 4:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 5:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 6:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 7:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 8:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 9:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 10:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 11:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 12:
+						value209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant231 = golem_core_types.MakeSchemaValueNodeStringValue(value209)
+
+					case 13:
+						result210 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result210 = append(result210, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant231 = golem_core_types.MakeSchemaValueNodeRecordValue(result210)
+
+					case 14:
+						var option211 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+						case 0:
+
+							option211 = witTypes.None[int32]()
+						case 1:
+
+							option211 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+						default:
+							panic("unreachable")
+						}
+
+						variant231 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option211})
+
+					case 15:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 16:
+						result212 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+							result212 = append(result212, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+						}
+
+						variant231 = golem_core_types.MakeSchemaValueNodeFlagsValue(result212)
+
+					case 17:
+						result213 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result213 = append(result213, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant231 = golem_core_types.MakeSchemaValueNodeTupleValue(result213)
+
+					case 18:
+						result214 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result214 = append(result214, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant231 = golem_core_types.MakeSchemaValueNodeListValue(result214)
+
+					case 19:
+						result215 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result215 = append(result215, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant231 = golem_core_types.MakeSchemaValueNodeFixedListValue(result215)
+
+					case 20:
+						result216 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+							result216 = append(result216, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+						}
+
+						variant231 = golem_core_types.MakeSchemaValueNodeMapValue(result216)
+
+					case 21:
+						var option217 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option217 = witTypes.None[int32]()
+						case 1:
+
+							option217 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant231 = golem_core_types.MakeSchemaValueNodeOptionValue(option217)
+
+					case 22:
+						var variant220 golem_core_types.ResultValuePayload
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+							var option218 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option218 = witTypes.None[int32]()
+							case 1:
+
+								option218 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant220 = golem_core_types.MakeResultValuePayloadOkValue(option218)
+
+						case 1:
+							var option219 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option219 = witTypes.None[int32]()
+							case 1:
+
+								option219 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant220 = golem_core_types.MakeResultValuePayloadErrValue(option219)
+
+						default:
+							panic("unreachable")
+						}
+
+						variant231 = golem_core_types.MakeSchemaValueNodeResultValue(variant220)
+
+					case 23:
+						value221 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var option223 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option223 = witTypes.None[string]()
+						case 1:
+							value222 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option223 = witTypes.Some[string](value222)
+						default:
+							panic("unreachable")
+						}
+
+						variant231 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value221, option223})
+
+					case 24:
+						value224 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var option226 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option226 = witTypes.None[string]()
+						case 1:
+							value225 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option226 = witTypes.Some[string](value225)
+						default:
+							panic("unreachable")
+						}
+
+						variant231 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value224, option226})
+
+					case 25:
+						value227 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant231 = golem_core_types.MakeSchemaValueNodePathValue(value227)
+
+					case 26:
+						value228 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant231 = golem_core_types.MakeSchemaValueNodeUrlValue(value228)
+
+					case 27:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+					case 28:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+					case 29:
+						value229 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						variant231 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value229})
+
+					case 30:
+						value230 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant231 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value230, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+					case 31:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+					case 32:
+
+						variant231 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+					default:
+						panic("unreachable")
+					}
+
+					result232 = append(result232, variant231)
+				}
+
+				variant233 = golem_agent_common.MakeAgentErrorCustomError(golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result204, result208, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (7 * 4)))}, golem_core_types.SchemaValueTree{result232, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (10 * 4)))}})
+
+			default:
+				panic("unreachable")
+			}
+
+			variant234 = MakeRpcErrorRemoteAgentError(variant233)
+
+		default:
+			panic("unreachable")
+		}
+
+		result235 = witTypes.Err[witTypes.Option[golem_core_types.SchemaValueTree], RpcError](variant234)
+	default:
+		panic("unreachable")
+	}
+
+	return result235
+
+}
+
+//go:wasmimport golem:agent/host@2.0.0 [method]future-invoke-result.cancel
+func wasm_import_method_future_invoke_result_cancel(arg0 int32)
+
+func (self *FutureInvokeResult) Cancel() {
+
+	wasm_import_method_future_invoke_result_cancel((self).Handle())
+
+}
+
+//go:wasmimport golem:agent/host@2.0.0 [method]cancellation-token.cancel
+func wasm_import_method_cancellation_token_cancel(arg0 int32)
+
+func (self *CancellationToken) Cancel() {
+
+	wasm_import_method_cancellation_token_cancel((self).Handle())
+
+}
+
+//go:wasmimport golem:agent/host@2.0.0 get-config-value
+func wasm_import_get_config_value(arg0 uintptr, arg1 uint32, arg2 uintptr, arg3 uint32, arg4 uintptr, arg5 uint32, arg6 int32, arg7 uintptr)
+
+func GetConfigValue(key []string, expected golem_core_types.SchemaGraph) golem_core_types.SchemaValueTree {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	slice := key
+	length := uint32(len(slice))
+	result := witRuntime.Allocate(pinner, uintptr(length*(2*4)), 4)
+	for index, element := range slice {
+		base := unsafe.Add(result, index*(2*4))
+		utf8 := unsafe.Pointer(unsafe.StringData(element))
+		pinner.Pin(utf8)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8)))
+
+	}
+
+	slice118 := (expected).TypeNodes
+	length120 := uint32(len(slice118))
+	result119 := witRuntime.Allocate(pinner, uintptr(length120*(56+22*4)), 8)
+	for index, element := range slice118 {
+		base := unsafe.Add(result119, index*(56+22*4))
+
+		switch (element).Body.Tag() {
+		case golem_core_types.SchemaTypeBodyRefType:
+			payload := (element).Body.RefType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaTypeBodyBoolType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+		case golem_core_types.SchemaTypeBodyS8Type:
+			payload := (element).Body.S8Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf80 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf80)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf80)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyS16Type:
+			payload := (element).Body.S16Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf81 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf81)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf81)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyS32Type:
+			payload := (element).Body.S32Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf82 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf82)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf82)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyS64Type:
+			payload := (element).Body.S64Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf83 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf83)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf83)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU8Type:
+			payload := (element).Body.U8Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf84 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf84)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf84)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU16Type:
+			payload := (element).Body.U16Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf85 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf85)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf85)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU32Type:
+			payload := (element).Body.U32Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf86 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf86)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf86)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU64Type:
+			payload := (element).Body.U64Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf87 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf87)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf87)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyF32Type:
+			payload := (element).Body.F32Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf88 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf88)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf88)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyF64Type:
+			payload := (element).Body.F64Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf89 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf89)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf89)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyCharType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+
+		case golem_core_types.SchemaTypeBodyStringType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+
+		case golem_core_types.SchemaTypeBodyRecordType:
+			payload := (element).Body.RecordType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			slice22 := payload
+			length24 := uint32(len(slice22))
+			result23 := witRuntime.Allocate(pinner, uintptr(length24*(17*4)), 4)
+			for index, element := range slice22 {
+				base := unsafe.Add(result23, index*(17*4))
+				utf810 := unsafe.Pointer(unsafe.StringData((element).Name))
+				pinner.Pin(utf810)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf810)))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+					utf811 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf811)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf811)))
+
+				default:
+					panic("unreachable")
+				}
+				slice13 := ((element).Metadata).Aliases
+				length15 := uint32(len(slice13))
+				result14 := witRuntime.Allocate(pinner, uintptr(length15*(2*4)), 4)
+				for index, element := range slice13 {
+					base := unsafe.Add(result14, index*(2*4))
+					utf812 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf812)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf812)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length15)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result14)))
+				slice17 := ((element).Metadata).Examples
+				length19 := uint32(len(slice17))
+				result18 := witRuntime.Allocate(pinner, uintptr(length19*(2*4)), 4)
+				for index, element := range slice17 {
+					base := unsafe.Add(result18, index*(2*4))
+					utf816 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf816)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf816)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = uint32(length19)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result18)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(1))
+					utf820 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf820)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf820)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(3))
+						utf821 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf821)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uintptr(uintptr(utf821)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length24)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result23)))
+
+		case golem_core_types.SchemaTypeBodyVariantType:
+			payload := (element).Body.VariantType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			slice37 := payload
+			length39 := uint32(len(slice37))
+			result38 := witRuntime.Allocate(pinner, uintptr(length39*(8+16*4)), 4)
+			for index, element := range slice37 {
+				base := unsafe.Add(result38, index*(8+16*4))
+				utf825 := unsafe.Pointer(unsafe.StringData((element).Name))
+				pinner.Pin(utf825)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf825)))
+
+				switch (element).Payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (element).Payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+					utf826 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf826)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf826)))
+
+				default:
+					panic("unreachable")
+				}
+				slice28 := ((element).Metadata).Aliases
+				length30 := uint32(len(slice28))
+				result29 := witRuntime.Allocate(pinner, uintptr(length30*(2*4)), 4)
+				for index, element := range slice28 {
+					base := unsafe.Add(result29, index*(2*4))
+					utf827 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf827)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf827)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length30)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result29)))
+				slice32 := ((element).Metadata).Examples
+				length34 := uint32(len(slice32))
+				result33 := witRuntime.Allocate(pinner, uintptr(length34*(2*4)), 4)
+				for index, element := range slice32 {
+					base := unsafe.Add(result33, index*(2*4))
+					utf831 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf831)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf831)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length34)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result33)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+					utf835 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf835)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf835)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+						utf836 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf836)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf836)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length39)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result38)))
+
+		case golem_core_types.SchemaTypeBodyEnumType:
+			payload := (element).Body.EnumType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			slice41 := payload
+			length43 := uint32(len(slice41))
+			result42 := witRuntime.Allocate(pinner, uintptr(length43*(2*4)), 4)
+			for index, element := range slice41 {
+				base := unsafe.Add(result42, index*(2*4))
+				utf840 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf840)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf840)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length43)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result42)))
+
+		case golem_core_types.SchemaTypeBodyFlagsType:
+			payload := (element).Body.FlagsType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			slice45 := payload
+			length47 := uint32(len(slice45))
+			result46 := witRuntime.Allocate(pinner, uintptr(length47*(2*4)), 4)
+			for index, element := range slice45 {
+				base := unsafe.Add(result46, index*(2*4))
+				utf844 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf844)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf844)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length47)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result46)))
+
+		case golem_core_types.SchemaTypeBodyTupleType:
+			payload := (element).Body.TupleType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			slice48 := payload
+			length50 := uint32(len(slice48))
+			result49 := witRuntime.Allocate(pinner, uintptr(length50*4), 4)
+			for index, element := range slice48 {
+				base := unsafe.Add(result49, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length50)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result49)))
+
+		case golem_core_types.SchemaTypeBodyListType:
+			payload := (element).Body.ListType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaTypeBodyFixedListType:
+			payload := (element).Body.FixedListType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Element
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Length)
+
+		case golem_core_types.SchemaTypeBodyMapType:
+			payload := (element).Body.MapType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Key
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Value
+
+		case golem_core_types.SchemaTypeBodyOptionType:
+			payload := (element).Body.OptionType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaTypeBodyResultType:
+			payload := (element).Body.ResultType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+			switch (payload).Ok.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Ok.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).Err.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Err.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyTextType:
+			payload := (element).Body.TextType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+			switch (payload).Languages.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Languages.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				slice52 := payload
+				length54 := uint32(len(slice52))
+				result53 := witRuntime.Allocate(pinner, uintptr(length54*(2*4)), 4)
+				for index, element := range slice52 {
+					base := unsafe.Add(result53, index*(2*4))
+					utf851 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf851)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf851)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length54)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result53)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MinLength.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MinLength.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MaxLength.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MaxLength.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).Regex.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Regex.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(1))
+				utf855 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf855)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = uint32(uintptr(uintptr(utf855)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyBinaryType:
+			payload := (element).Body.BinaryType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+
+			switch (payload).MimeTypes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MimeTypes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				slice57 := payload
+				length59 := uint32(len(slice57))
+				result58 := witRuntime.Allocate(pinner, uintptr(length59*(2*4)), 4)
+				for index, element := range slice57 {
+					base := unsafe.Add(result58, index*(2*4))
+					utf856 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf856)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf856)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length59)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result58)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MinBytes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MinBytes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MaxBytes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MaxBytes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyPathType:
+			payload := (element).Body.PathType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Direction))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Kind))
+
+			switch (payload).AllowedMimeTypes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedMimeTypes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+				slice61 := payload
+				length63 := uint32(len(slice61))
+				result62 := witRuntime.Allocate(pinner, uintptr(length63*(2*4)), 4)
+				for index, element := range slice61 {
+					base := unsafe.Add(result62, index*(2*4))
+					utf860 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf860)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf860)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length63)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result62)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).AllowedExtensions.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedExtensions.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+				slice65 := payload
+				length67 := uint32(len(slice65))
+				result66 := witRuntime.Allocate(pinner, uintptr(length67*(2*4)), 4)
+				for index, element := range slice65 {
+					base := unsafe.Add(result66, index*(2*4))
+					utf864 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf864)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf864)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length67)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result66)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyUrlType:
+			payload := (element).Body.UrlType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+
+			switch (payload).AllowedSchemes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedSchemes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				slice69 := payload
+				length71 := uint32(len(slice69))
+				result70 := witRuntime.Allocate(pinner, uintptr(length71*(2*4)), 4)
+				for index, element := range slice69 {
+					base := unsafe.Add(result70, index*(2*4))
+					utf868 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf868)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf868)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length71)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result70)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).AllowedHosts.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedHosts.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				slice73 := payload
+				length75 := uint32(len(slice73))
+				result74 := witRuntime.Allocate(pinner, uintptr(length75*(2*4)), 4)
+				for index, element := range slice73 {
+					base := unsafe.Add(result74, index*(2*4))
+					utf872 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf872)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf872)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(length75)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(result74)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyDatetimeType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+		case golem_core_types.SchemaTypeBodyDurationType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+		case golem_core_types.SchemaTypeBodyQuantityType:
+			payload := (element).Body.QuantityType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			utf876 := unsafe.Pointer(unsafe.StringData((payload).BaseUnit))
+			pinner.Pin(utf876)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).BaseUnit)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf876)))
+			slice78 := (payload).AllowedSuffixes
+			length80 := uint32(len(slice78))
+			result79 := witRuntime.Allocate(pinner, uintptr(length80*(2*4)), 4)
+			for index, element := range slice78 {
+				base := unsafe.Add(result79, index*(2*4))
+				utf877 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf877)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf877)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result79)))
+
+			switch (payload).Min.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Min.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))) = (payload).Mantissa
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = (payload).Scale
+				utf881 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+				pinner.Pin(utf881)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))) = uint32(uint32(len((payload).Unit)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uintptr(uintptr(utf881)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).Max.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Max.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))) = (payload).Mantissa
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))) = (payload).Scale
+				utf882 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+				pinner.Pin(utf882)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))) = uint32(uint32(len((payload).Unit)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4))) = uint32(uintptr(uintptr(utf882)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyUnionType:
+			payload := (element).Body.UnionType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			slice102 := (payload).Branches
+			length104 := uint32(len(slice102))
+			result103 := witRuntime.Allocate(pinner, uintptr(length104*(23*4)), 4)
+			for index, element := range slice102 {
+				base := unsafe.Add(result103, index*(23*4))
+				utf883 := unsafe.Pointer(unsafe.StringData((element).Tag))
+				pinner.Pin(utf883)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Tag)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf883)))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+				switch (element).Discriminator.Tag() {
+				case golem_core_types.DiscriminatorRulePrefix:
+					payload := (element).Discriminator.Prefix()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+					utf884 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf884)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf884)))
+
+				case golem_core_types.DiscriminatorRuleSuffix:
+					payload := (element).Discriminator.Suffix()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+					utf885 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf885)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf885)))
+
+				case golem_core_types.DiscriminatorRuleContains:
+					payload := (element).Discriminator.Contains()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(2))
+					utf886 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf886)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf886)))
+
+				case golem_core_types.DiscriminatorRuleRegex:
+					payload := (element).Discriminator.Regex()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(3))
+					utf887 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf887)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf887)))
+
+				case golem_core_types.DiscriminatorRuleFieldEquals:
+					payload := (element).Discriminator.FieldEquals()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(4))
+					utf888 := unsafe.Pointer(unsafe.StringData((payload).FieldName))
+					pinner.Pin(utf888)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((payload).FieldName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf888)))
+
+					switch (payload).Literal.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Literal.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+						utf889 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf889)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf889)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.DiscriminatorRuleFieldAbsent:
+					payload := (element).Discriminator.FieldAbsent()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(5))
+					utf890 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf890)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf890)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+					utf891 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf891)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(utf891)))
+
+				default:
+					panic("unreachable")
+				}
+				slice93 := ((element).Metadata).Aliases
+				length95 := uint32(len(slice93))
+				result94 := witRuntime.Allocate(pinner, uintptr(length95*(2*4)), 4)
+				for index, element := range slice93 {
+					base := unsafe.Add(result94, index*(2*4))
+					utf892 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf892)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf892)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(length95)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(result94)))
+				slice97 := ((element).Metadata).Examples
+				length99 := uint32(len(slice97))
+				result98 := witRuntime.Allocate(pinner, uintptr(length99*(2*4)), 4)
+				for index, element := range slice97 {
+					base := unsafe.Add(result98, index*(2*4))
+					utf896 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf896)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf896)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(length99)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(result98)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(1))
+					utf8100 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8100)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf8100)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(3))
+						utf8101 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8101)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(utf8101)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length104)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result103)))
+
+		case golem_core_types.SchemaTypeBodySecretType:
+			payload := (element).Body.SecretType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Inner
+
+			switch (payload).Category.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Category.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+				utf8105 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8105)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8105)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyQuotaTokenType:
+			payload := (element).Body.QuotaTokenType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+			switch (payload).ResourceName.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).ResourceName.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				utf8106 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8106)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf8106)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyFutureType:
+			payload := (element).Body.FutureType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyStreamType:
+			payload := (element).Body.StreamType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		default:
+			panic("unreachable")
+		}
+
+		switch ((element).Metadata).Doc.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Metadata).Doc.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(1))
+			utf8107 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8107)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4))) = uint32(uintptr(uintptr(utf8107)))
+
+		default:
+			panic("unreachable")
+		}
+		slice109 := ((element).Metadata).Aliases
+		length111 := uint32(len(slice109))
+		result110 := witRuntime.Allocate(pinner, uintptr(length111*(2*4)), 4)
+		for index, element := range slice109 {
+			base := unsafe.Add(result110, index*(2*4))
+			utf8108 := unsafe.Pointer(unsafe.StringData(element))
+			pinner.Pin(utf8108)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8108)))
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length111)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result110)))
+		slice113 := ((element).Metadata).Examples
+		length115 := uint32(len(slice113))
+		result114 := witRuntime.Allocate(pinner, uintptr(length115*(2*4)), 4)
+		for index, element := range slice113 {
+			base := unsafe.Add(result114, index*(2*4))
+			utf8112 := unsafe.Pointer(unsafe.StringData(element))
+			pinner.Pin(utf8112)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8112)))
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length115)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result114)))
+
+		switch ((element).Metadata).Deprecated.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Metadata).Deprecated.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(1))
+			utf8116 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8116)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4))) = uint32(uintptr(uintptr(utf8116)))
+
+		default:
+			panic("unreachable")
+		}
+
+		switch ((element).Metadata).Role.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Metadata).Role.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(1))
+
+			switch payload.Tag() {
+			case golem_core_types.RoleMultimodal:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(0))
+
+			case golem_core_types.RoleUnstructuredText:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(1))
+
+			case golem_core_types.RoleUnstructuredBinary:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(2))
+
+			case golem_core_types.RoleOther:
+				payload := payload.Other()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(3))
+				utf8117 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8117)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4))) = uint32(uintptr(uintptr(utf8117)))
+
+			default:
+				panic("unreachable")
+			}
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	slice123 := (expected).Defs
+	length125 := uint32(len(slice123))
+	result124 := witRuntime.Allocate(pinner, uintptr(length125*(6*4)), 4)
+	for index, element := range slice123 {
+		base := unsafe.Add(result124, index*(6*4))
+		utf8121 := unsafe.Pointer(unsafe.StringData((element).Id))
+		pinner.Pin(utf8121)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8121)))
+
+		switch (element).Name.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := (element).Name.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+			utf8122 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8122)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8122)))
+
+		default:
+			panic("unreachable")
+		}
+		*(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body
+
+	}
+
+	wasm_import_get_config_value(uintptr(result), length, uintptr(result119), length120, uintptr(result124), length125, (expected).Root, returnArea)
+	result146 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)))), index*(16+4*4))
+		var variant145 golem_core_types.SchemaValueNode
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+		case 0:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+		case 1:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+		case 2:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+		case 3:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+		case 4:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+		case 5:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+		case 6:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+		case 7:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+		case 8:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+		case 9:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+		case 10:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+		case 11:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+		case 12:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+			variant145 = golem_core_types.MakeSchemaValueNodeStringValue(value)
+
+		case 13:
+			result126 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+				result126 = append(result126, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+			}
+
+			variant145 = golem_core_types.MakeSchemaValueNodeRecordValue(result126)
+
+		case 14:
+			var option witTypes.Option[int32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+			case 0:
+
+				option = witTypes.None[int32]()
+			case 1:
+
+				option = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+			default:
+				panic("unreachable")
+			}
+
+			variant145 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option})
+
+		case 15:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+		case 16:
+			result127 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+				result127 = append(result127, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+			}
+
+			variant145 = golem_core_types.MakeSchemaValueNodeFlagsValue(result127)
+
+		case 17:
+			result128 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+				result128 = append(result128, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+			}
+
+			variant145 = golem_core_types.MakeSchemaValueNodeTupleValue(result128)
+
+		case 18:
+			result129 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+				result129 = append(result129, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+			}
+
+			variant145 = golem_core_types.MakeSchemaValueNodeListValue(result129)
+
+		case 19:
+			result130 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+				result130 = append(result130, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+			}
+
+			variant145 = golem_core_types.MakeSchemaValueNodeFixedListValue(result130)
+
+		case 20:
+			result131 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+				result131 = append(result131, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+			}
+
+			variant145 = golem_core_types.MakeSchemaValueNodeMapValue(result131)
+
+		case 21:
+			var option132 witTypes.Option[int32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option132 = witTypes.None[int32]()
+			case 1:
+
+				option132 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+			default:
+				panic("unreachable")
+			}
+
+			variant145 = golem_core_types.MakeSchemaValueNodeOptionValue(option132)
+
+		case 22:
+			var variant golem_core_types.ResultValuePayload
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+				var option133 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+				case 0:
+
+					option133 = witTypes.None[int32]()
+				case 1:
+
+					option133 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+				default:
+					panic("unreachable")
+				}
+
+				variant = golem_core_types.MakeResultValuePayloadOkValue(option133)
+
+			case 1:
+				var option134 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+				case 0:
+
+					option134 = witTypes.None[int32]()
+				case 1:
+
+					option134 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+				default:
+					panic("unreachable")
+				}
+
+				variant = golem_core_types.MakeResultValuePayloadErrValue(option134)
+
+			default:
+				panic("unreachable")
+			}
+
+			variant145 = golem_core_types.MakeSchemaValueNodeResultValue(variant)
+
+		case 23:
+			value135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			var option137 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+			case 0:
+
+				option137 = witTypes.None[string]()
+			case 1:
+				value136 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+				option137 = witTypes.Some[string](value136)
+			default:
+				panic("unreachable")
+			}
+
+			variant145 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value135, option137})
+
+		case 24:
+			value138 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			var option140 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+			case 0:
+
+				option140 = witTypes.None[string]()
+			case 1:
+				value139 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+				option140 = witTypes.Some[string](value139)
+			default:
+				panic("unreachable")
+			}
+
+			variant145 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value138, option140})
+
+		case 25:
+			value141 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+			variant145 = golem_core_types.MakeSchemaValueNodePathValue(value141)
+
+		case 26:
+			value142 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+			variant145 = golem_core_types.MakeSchemaValueNodeUrlValue(value142)
+
+		case 27:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+		case 28:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+		case 29:
+			value143 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+			variant145 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value143})
+
+		case 30:
+			value144 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+			variant145 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value144, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+		case 31:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+		case 32:
+
+			variant145 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+		default:
+			panic("unreachable")
+		}
+
+		result146 = append(result146, variant145)
+	}
+
+	result147 := golem_core_types.SchemaValueTree{result146, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))}
+	return result147
+
+}
diff --git a/sdks/go/golem/internal/wit/golem_api_context/empty.s b/sdks/go/golem/internal/wit/golem_api_context/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_api_context/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_api_context/wit_bindings.go b/sdks/go/golem/internal/wit/golem_api_context/wit_bindings.go
new file mode 100644
index 0000000000..f6440479cd
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_api_context/wit_bindings.go
@@ -0,0 +1,533 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_api_context
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_system_clock"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type Datetime = wasi_clocks_0_3_0_system_clock.Instant
+
+//go:wasmimport golem:api/context@1.5.0 [resource-drop]span
+func resourceDropSpan(handle int32)
+
+// Represents a unit of work or operation
+type Span struct {
+	handle *witRuntime.Handle
+}
+
+func (self *Span) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *Span) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *Span) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *Span) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropSpan(handle)
+	}
+}
+
+func SpanFromOwnHandle(handleValue int32) *Span {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &Span{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropSpan(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func SpanFromBorrowHandle(handleValue int32) *Span {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &Span{handle}
+}
+
+//go:wasmimport golem:api/context@1.5.0 [resource-drop]invocation-context
+func resourceDropInvocationContext(handle int32)
+
+// Represents an invocation context wich allows querying the stack of attributes
+// created by automatic and user-defined spans.
+type InvocationContext struct {
+	handle *witRuntime.Handle
+}
+
+func (self *InvocationContext) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *InvocationContext) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *InvocationContext) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *InvocationContext) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropInvocationContext(handle)
+	}
+}
+
+func InvocationContextFromOwnHandle(handleValue int32) *InvocationContext {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &InvocationContext{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropInvocationContext(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func InvocationContextFromBorrowHandle(handleValue int32) *InvocationContext {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &InvocationContext{handle}
+}
+
+const (
+	// A string value
+	AttributeValueString uint8 = 0
+)
+
+// Possible span attribute value types
+type AttributeValue struct {
+	tag   uint8
+	value any
+}
+
+func (self AttributeValue) Tag() uint8 {
+	return self.tag
+}
+
+func (self AttributeValue) String() string {
+	if self.tag != AttributeValueString {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+
+func MakeAttributeValueString(value string) AttributeValue {
+	return AttributeValue{AttributeValueString, value}
+}
+
+// An attribute of a span
+type Attribute struct {
+	Key   string
+	Value AttributeValue
+}
+
+// A chain of attribute values, the first element representing the most recent value
+type AttributeChain struct {
+	Key    string
+	Values []AttributeValue
+}
+
+// The trace represented by a 16 bytes hexadecimal string
+type TraceId = string
+
+// The span represented by a 8 bytes hexadecimal string
+type SpanId = string
+
+//go:wasmimport golem:api/context@1.5.0 start-span
+func wasm_import_start_span(arg0 uintptr, arg1 uint32) int32
+
+func StartSpan(name string) *Span {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	result := wasm_import_start_span(uintptr(utf8), uint32(len(name)))
+	return SpanFromOwnHandle(int32(uintptr(result)))
+
+}
+
+//go:wasmimport golem:api/context@1.5.0 current-context
+func wasm_import_current_context() int32
+
+func CurrentContext() *InvocationContext {
+
+	result := wasm_import_current_context()
+	return InvocationContextFromOwnHandle(int32(uintptr(result)))
+
+}
+
+//go:wasmimport golem:api/context@1.5.0 allow-forwarding-trace-context-headers
+func wasm_import_allow_forwarding_trace_context_headers(arg0 int32) int32
+
+func AllowForwardingTraceContextHeaders(allow bool) bool {
+
+	var result int32
+	if allow {
+		result = 1
+	} else {
+		result = 0
+	}
+	result0 := wasm_import_allow_forwarding_trace_context_headers(result)
+	return (result0 != 0)
+
+}
+
+//go:wasmimport golem:api/context@1.5.0 [method]span.started-at
+func wasm_import_method_span_started_at(arg0 int32, arg1 uintptr)
+
+func (self *Span) StartedAt() wasi_clocks_0_3_0_system_clock.Instant {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 16, 8))
+	wasm_import_method_span_started_at((self).Handle(), returnArea)
+	result := wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 0)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))}
+	return result
+
+}
+
+//go:wasmimport golem:api/context@1.5.0 [method]span.set-attribute
+func wasm_import_method_span_set_attribute(arg0 int32, arg1 uintptr, arg2 uint32, arg3 int32, arg4 uintptr, arg5 uint32)
+
+func (self *Span) SetAttribute(name string, value AttributeValue) {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	var variant int32
+	var variant1 uintptr
+	var variant2 uint32
+	switch value.Tag() {
+	case AttributeValueString:
+		payload := value.String()
+		utf80 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf80)
+
+		variant = int32(0)
+		variant1 = uintptr(utf80)
+		variant2 = uint32(len(payload))
+
+	default:
+		panic("unreachable")
+	}
+	wasm_import_method_span_set_attribute((self).Handle(), uintptr(utf8), uint32(len(name)), variant, variant1, variant2)
+
+}
+
+//go:wasmimport golem:api/context@1.5.0 [method]span.set-attributes
+func wasm_import_method_span_set_attributes(arg0 int32, arg1 uintptr, arg2 uint32)
+
+func (self *Span) SetAttributes(attributes []Attribute) {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	slice := attributes
+	length := uint32(len(slice))
+	result := witRuntime.Allocate(pinner, uintptr(length*(5*4)), 4)
+	for index, element := range slice {
+		base := unsafe.Add(result, index*(5*4))
+		utf8 := unsafe.Pointer(unsafe.StringData((element).Key))
+		pinner.Pin(utf8)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Key)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8)))
+
+		switch (element).Value.Tag() {
+		case AttributeValueString:
+			payload := (element).Value.String()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf80)))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_span_set_attributes((self).Handle(), uintptr(result), length)
+
+}
+
+//go:wasmimport golem:api/context@1.5.0 [method]span.finish
+func wasm_import_method_span_finish(arg0 int32)
+
+func (self *Span) Finish() {
+
+	wasm_import_method_span_finish((self).Handle())
+
+}
+
+//go:wasmimport golem:api/context@1.5.0 [method]invocation-context.trace-id
+func wasm_import_method_invocation_context_trace_id(arg0 int32, arg1 uintptr)
+
+func (self *InvocationContext) TraceId() string {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	wasm_import_method_invocation_context_trace_id((self).Handle(), returnArea)
+	value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	result := value
+	return result
+
+}
+
+//go:wasmimport golem:api/context@1.5.0 [method]invocation-context.span-id
+func wasm_import_method_invocation_context_span_id(arg0 int32, arg1 uintptr)
+
+func (self *InvocationContext) SpanId() string {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	wasm_import_method_invocation_context_span_id((self).Handle(), returnArea)
+	value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	result := value
+	return result
+
+}
+
+//go:wasmimport golem:api/context@1.5.0 [method]invocation-context.parent
+func wasm_import_method_invocation_context_parent(arg0 int32, arg1 uintptr)
+
+func (self *InvocationContext) Parent() witTypes.Option[*InvocationContext] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
+	wasm_import_method_invocation_context_parent((self).Handle(), returnArea)
+	var option witTypes.Option[*InvocationContext]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[*InvocationContext]()
+	case 1:
+
+		option = witTypes.Some[*InvocationContext](InvocationContextFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	default:
+		panic("unreachable")
+	}
+	result := option
+	return result
+
+}
+
+//go:wasmimport golem:api/context@1.5.0 [method]invocation-context.get-attribute
+func wasm_import_method_invocation_context_get_attribute(arg0 int32, arg1 uintptr, arg2 uint32, arg3 int32, arg4 uintptr)
+
+func (self *InvocationContext) GetAttribute(key string, inherited bool) witTypes.Option[AttributeValue] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(key))
+	pinner.Pin(utf8)
+	var result int32
+	if inherited {
+		result = 1
+	} else {
+		result = 0
+	}
+	wasm_import_method_invocation_context_get_attribute((self).Handle(), uintptr(utf8), uint32(len(key)), result, returnArea)
+	var option witTypes.Option[AttributeValue]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[AttributeValue]()
+	case 1:
+		var variant AttributeValue
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeAttributeValueString(value)
+
+		default:
+			panic("unreachable")
+		}
+
+		option = witTypes.Some[AttributeValue](variant)
+	default:
+		panic("unreachable")
+	}
+	result0 := option
+	return result0
+
+}
+
+//go:wasmimport golem:api/context@1.5.0 [method]invocation-context.get-attributes
+func wasm_import_method_invocation_context_get_attributes(arg0 int32, arg1 int32, arg2 uintptr)
+
+func (self *InvocationContext) GetAttributes(inherited bool) []Attribute {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	var result int32
+	if inherited {
+		result = 1
+	} else {
+		result = 0
+	}
+	wasm_import_method_invocation_context_get_attributes((self).Handle(), result, returnArea)
+	result1 := make([]Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)))), index*(5*4))
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+		var variant AttributeValue
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+		case 0:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+			variant = MakeAttributeValueString(value0)
+
+		default:
+			panic("unreachable")
+		}
+
+		result1 = append(result1, Attribute{value, variant})
+	}
+
+	result2 := result1
+	return result2
+
+}
+
+//go:wasmimport golem:api/context@1.5.0 [method]invocation-context.get-attribute-chain
+func wasm_import_method_invocation_context_get_attribute_chain(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
+
+func (self *InvocationContext) GetAttributeChain(key string) []AttributeValue {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(key))
+	pinner.Pin(utf8)
+	wasm_import_method_invocation_context_get_attribute_chain((self).Handle(), uintptr(utf8), uint32(len(key)), returnArea)
+	result := make([]AttributeValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)))), index*(3*4))
+		var variant AttributeValue
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+			variant = MakeAttributeValueString(value)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = append(result, variant)
+	}
+
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport golem:api/context@1.5.0 [method]invocation-context.get-attribute-chains
+func wasm_import_method_invocation_context_get_attribute_chains(arg0 int32, arg1 uintptr)
+
+func (self *InvocationContext) GetAttributeChains() []AttributeChain {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	wasm_import_method_invocation_context_get_attribute_chains((self).Handle(), returnArea)
+	result1 := make([]AttributeChain, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)))), index*(4*4))
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+		result := make([]AttributeValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))), index*(3*4))
+			var variant AttributeValue
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+				value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))
+
+				variant = MakeAttributeValueString(value0)
+
+			default:
+				panic("unreachable")
+			}
+
+			result = append(result, variant)
+		}
+
+		result1 = append(result1, AttributeChain{value, result})
+	}
+
+	result2 := result1
+	return result2
+
+}
+
+//go:wasmimport golem:api/context@1.5.0 [method]invocation-context.trace-context-headers
+func wasm_import_method_invocation_context_trace_context_headers(arg0 int32, arg1 uintptr)
+
+func (self *InvocationContext) TraceContextHeaders() []witTypes.Tuple2[string, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	wasm_import_method_invocation_context_trace_context_headers((self).Handle(), returnArea)
+	result := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)))), index*(4*4))
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+		value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+		result = append(result, witTypes.Tuple2[string, string]{value, value0})
+	}
+
+	result1 := result
+	return result1
+
+}
diff --git a/sdks/go/golem/internal/wit/golem_api_host/empty.s b/sdks/go/golem/internal/wit/golem_api_host/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_api_host/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_api_host/wit_bindings.go b/sdks/go/golem/internal/wit/golem_api_host/wit_bindings.go
new file mode 100644
index 0000000000..2d8ce41556
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_api_host/wit_bindings.go
@@ -0,0 +1,1192 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_api_host
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	witAsync "go.bytecodealliance.org/pkg/wit/async"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type ComponentId = golem_core_types.ComponentId
+type CardId = golem_core_types.CardId
+type Uuid = golem_core_types.Uuid
+type AgentId = golem_core_types.AgentId
+type PromiseId = golem_core_types.PromiseId
+type OplogIndex = uint64
+
+// Represents a Golem component's version
+type ComponentRevision = uint64
+
+// Represents a Golem environment
+type EnvironmentId struct {
+	Uuid golem_core_types.Uuid
+}
+
+const (
+	PersistenceLevelPersistNothing           uint8 = 0
+	PersistenceLevelPersistRemoteSideEffects uint8 = 1
+	PersistenceLevelSmart                    uint8 = 2
+)
+
+// Configurable persistence level for agents
+type PersistenceLevel struct {
+	tag   uint8
+	value any
+}
+
+func (self PersistenceLevel) Tag() uint8 {
+	return self.tag
+}
+
+func MakePersistenceLevelPersistNothing() PersistenceLevel {
+	return PersistenceLevel{PersistenceLevelPersistNothing, nil}
+}
+func MakePersistenceLevelPersistRemoteSideEffects() PersistenceLevel {
+	return PersistenceLevel{PersistenceLevelPersistRemoteSideEffects, nil}
+}
+func MakePersistenceLevelSmart() PersistenceLevel {
+	return PersistenceLevel{PersistenceLevelSmart, nil}
+}
+
+const (
+	// Automatic update tries to recover the agent using the new component version
+	// and may fail if there is a divergence.
+	UpdateModeAutomatic uint8 = 0
+	// Manual, snapshot-based update uses a user-defined implementation of the `save-snapshot` interface
+	// to store the agent's state, and a user-defined implementation of the `load-snapshot` interface to
+	// load it into the new version.
+	UpdateModeSnapshotBased uint8 = 1
+)
+
+// Describes how to update an agent to a different component version
+type UpdateMode = uint8
+
+const (
+	FilterComparatorEqual        uint8 = 0
+	FilterComparatorNotEqual     uint8 = 1
+	FilterComparatorGreaterEqual uint8 = 2
+	FilterComparatorGreater      uint8 = 3
+	FilterComparatorLessEqual    uint8 = 4
+	FilterComparatorLess         uint8 = 5
+)
+
+// Operators used in filtering enumerated agents
+type FilterComparator = uint8
+
+const (
+	StringFilterComparatorEqual      uint8 = 0
+	StringFilterComparatorNotEqual   uint8 = 1
+	StringFilterComparatorLike       uint8 = 2
+	StringFilterComparatorNotLike    uint8 = 3
+	StringFilterComparatorStartsWith uint8 = 4
+)
+
+// Operators used on strings in filtering enumerated agents
+type StringFilterComparator = uint8
+
+const (
+	// The agent is running an invoked function
+	AgentStatusRunning uint8 = 0
+	// The agent is ready to run an invoked function
+	AgentStatusIdle uint8 = 1
+	// An invocation is active but waiting for something (sleeping, waiting for a promise)
+	AgentStatusSuspended uint8 = 2
+	// The last invocation was interrupted but will be resumed
+	AgentStatusInterrupted uint8 = 3
+	// The last invocation failed and a retry was scheduled
+	AgentStatusRetrying uint8 = 4
+	// The last invocation failed and the agent can no longer be used
+	AgentStatusFailed uint8 = 5
+	// The agent exited after a successful invocation and can no longer be invoked
+	AgentStatusExited uint8 = 6
+)
+
+// The current status of an agent
+type AgentStatus = uint8
+
+// Describes a filter condition on agent IDs when enumerating agents
+type AgentNameFilter struct {
+	Comparator StringFilterComparator
+	Value      string
+}
+
+// Describes a filter condition on the agent status when enumerating agents
+type AgentStatusFilter struct {
+	Comparator FilterComparator
+	Value      AgentStatus
+}
+
+// Describes a filter condition on the component version when enumerating agents
+type AgentVersionFilter struct {
+	Comparator FilterComparator
+	Value      uint64
+}
+
+// Describes a filter condition on the agent's creation time when enumerating agents
+type AgentCreatedAtFilter struct {
+	Comparator FilterComparator
+	Value      uint64
+}
+
+// Describes a filter condition on the agent's environment variables when enumerating agents
+type AgentEnvFilter struct {
+	Name       string
+	Comparator StringFilterComparator
+	Value      string
+}
+
+// Describes a filter condition on the agent's configuration variables when enumerating agents
+type AgentConfigVarsFilter struct {
+	Name       string
+	Comparator StringFilterComparator
+	Value      string
+}
+
+const (
+	AgentPropertyFilterName      uint8 = 0
+	AgentPropertyFilterStatus    uint8 = 1
+	AgentPropertyFilterVersion   uint8 = 2
+	AgentPropertyFilterCreatedAt uint8 = 3
+	AgentPropertyFilterEnv       uint8 = 4
+	AgentPropertyFilterConfig    uint8 = 5
+)
+
+// Describes one filter condition for enumerating agents
+type AgentPropertyFilter struct {
+	tag   uint8
+	value any
+}
+
+func (self AgentPropertyFilter) Tag() uint8 {
+	return self.tag
+}
+
+func (self AgentPropertyFilter) Name() AgentNameFilter {
+	if self.tag != AgentPropertyFilterName {
+		panic("tag mismatch")
+	}
+	return self.value.(AgentNameFilter)
+}
+func (self AgentPropertyFilter) Status() AgentStatusFilter {
+	if self.tag != AgentPropertyFilterStatus {
+		panic("tag mismatch")
+	}
+	return self.value.(AgentStatusFilter)
+}
+func (self AgentPropertyFilter) Version() AgentVersionFilter {
+	if self.tag != AgentPropertyFilterVersion {
+		panic("tag mismatch")
+	}
+	return self.value.(AgentVersionFilter)
+}
+func (self AgentPropertyFilter) CreatedAt() AgentCreatedAtFilter {
+	if self.tag != AgentPropertyFilterCreatedAt {
+		panic("tag mismatch")
+	}
+	return self.value.(AgentCreatedAtFilter)
+}
+func (self AgentPropertyFilter) Env() AgentEnvFilter {
+	if self.tag != AgentPropertyFilterEnv {
+		panic("tag mismatch")
+	}
+	return self.value.(AgentEnvFilter)
+}
+func (self AgentPropertyFilter) Config() AgentConfigVarsFilter {
+	if self.tag != AgentPropertyFilterConfig {
+		panic("tag mismatch")
+	}
+	return self.value.(AgentConfigVarsFilter)
+}
+
+func MakeAgentPropertyFilterName(value AgentNameFilter) AgentPropertyFilter {
+	return AgentPropertyFilter{AgentPropertyFilterName, value}
+}
+func MakeAgentPropertyFilterStatus(value AgentStatusFilter) AgentPropertyFilter {
+	return AgentPropertyFilter{AgentPropertyFilterStatus, value}
+}
+func MakeAgentPropertyFilterVersion(value AgentVersionFilter) AgentPropertyFilter {
+	return AgentPropertyFilter{AgentPropertyFilterVersion, value}
+}
+func MakeAgentPropertyFilterCreatedAt(value AgentCreatedAtFilter) AgentPropertyFilter {
+	return AgentPropertyFilter{AgentPropertyFilterCreatedAt, value}
+}
+func MakeAgentPropertyFilterEnv(value AgentEnvFilter) AgentPropertyFilter {
+	return AgentPropertyFilter{AgentPropertyFilterEnv, value}
+}
+func MakeAgentPropertyFilterConfig(value AgentConfigVarsFilter) AgentPropertyFilter {
+	return AgentPropertyFilter{AgentPropertyFilterConfig, value}
+}
+
+// Combines multiple filter conditions with an `AND` relationship for enumerating agents
+type AgentAllFilter struct {
+	Filters []AgentPropertyFilter
+}
+
+// Combines multiple groups of filter conditions with an `OR` relationship for enumerating agents
+type AgentAnyFilter struct {
+	Filters []AgentAllFilter
+}
+
+// Metadata about an agent
+type AgentMetadata struct {
+	// The agent ID, consists of the component ID, agent type and agent parameters
+	AgentId golem_core_types.AgentId
+	// Command line arguments seen by the agent
+	Args []string
+	// Environment variables seen by the agent
+	Env []witTypes.Tuple2[string, string]
+	// Configuration variables seen by the agent
+	Config []witTypes.Tuple2[string, string]
+	// The current agent status
+	Status AgentStatus
+	// The component version the agent is running with
+	ComponentRevision uint64
+	// The agent's current retry count
+	RetryCount uint64
+	// The environment the agent belongs to
+	EnvironmentId EnvironmentId
+}
+
+//go:wasmimport golem:api/host@1.5.0 [resource-drop]get-agents
+func resourceDropGetAgents(handle int32)
+
+// Creates an agent enumeration
+type GetAgents struct {
+	handle *witRuntime.Handle
+}
+
+func (self *GetAgents) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *GetAgents) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *GetAgents) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *GetAgents) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropGetAgents(handle)
+	}
+}
+
+func GetAgentsFromOwnHandle(handleValue int32) *GetAgents {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &GetAgents{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropGetAgents(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func GetAgentsFromBorrowHandle(handleValue int32) *GetAgents {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &GetAgents{handle}
+}
+
+const (
+	// Revert to a specific oplog index. The given index will be the last one to be kept.
+	RevertAgentTargetRevertToOplogIndex uint8 = 0
+	// Revert the last N invocations.
+	RevertAgentTargetRevertLastInvocations uint8 = 1
+)
+
+// Target parameter for the `revert-agent` operation
+type RevertAgentTarget struct {
+	tag   uint8
+	value any
+}
+
+func (self RevertAgentTarget) Tag() uint8 {
+	return self.tag
+}
+
+func (self RevertAgentTarget) RevertToOplogIndex() uint64 {
+	if self.tag != RevertAgentTargetRevertToOplogIndex {
+		panic("tag mismatch")
+	}
+	return self.value.(uint64)
+}
+func (self RevertAgentTarget) RevertLastInvocations() uint64 {
+	if self.tag != RevertAgentTargetRevertLastInvocations {
+		panic("tag mismatch")
+	}
+	return self.value.(uint64)
+}
+
+func MakeRevertAgentTargetRevertToOplogIndex(value uint64) RevertAgentTarget {
+	return RevertAgentTarget{RevertAgentTargetRevertToOplogIndex, value}
+}
+func MakeRevertAgentTargetRevertLastInvocations(value uint64) RevertAgentTarget {
+	return RevertAgentTarget{RevertAgentTargetRevertLastInvocations, value}
+}
+
+// Details about the fork result
+type ForkDetails struct {
+	ForkedPhantomId golem_core_types.Uuid
+}
+
+const (
+	// The original agent that called `fork`
+	ForkResultOriginal uint8 = 0
+	// The new agent
+	ForkResultForked uint8 = 1
+)
+
+// Indicates which agent the code is running on after `fork`.
+// The parameter contains details about the fork result, such as the phantom-ID of the newly
+// created agent.
+type ForkResult struct {
+	tag   uint8
+	value any
+}
+
+func (self ForkResult) Tag() uint8 {
+	return self.tag
+}
+
+func (self ForkResult) Original() ForkDetails {
+	if self.tag != ForkResultOriginal {
+		panic("tag mismatch")
+	}
+	return self.value.(ForkDetails)
+}
+func (self ForkResult) Forked() ForkDetails {
+	if self.tag != ForkResultForked {
+		panic("tag mismatch")
+	}
+	return self.value.(ForkDetails)
+}
+
+func MakeForkResultOriginal(value ForkDetails) ForkResult {
+	return ForkResult{ForkResultOriginal, value}
+}
+func MakeForkResultForked(value ForkDetails) ForkResult {
+	return ForkResult{ForkResultForked, value}
+}
+
+//go:wasmimport golem:api/host@1.5.0 [resource-drop]get-promise-result
+func resourceDropGetPromiseResult(handle int32)
+
+type GetPromiseResult struct {
+	handle *witRuntime.Handle
+}
+
+func (self *GetPromiseResult) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *GetPromiseResult) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *GetPromiseResult) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *GetPromiseResult) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropGetPromiseResult(handle)
+	}
+}
+
+func GetPromiseResultFromOwnHandle(handleValue int32) *GetPromiseResult {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &GetPromiseResult{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropGetPromiseResult(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func GetPromiseResultFromBorrowHandle(handleValue int32) *GetPromiseResult {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &GetPromiseResult{handle}
+}
+
+// Plain-data handle to a permission card visible to the guest.
+type Card struct {
+	CardId golem_core_types.CardId
+}
+
+const (
+	CardInstallErrorRevoked      uint8 = 0
+	CardInstallErrorNotFound     uint8 = 1
+	CardInstallErrorNotPermitted uint8 = 2
+)
+
+type CardInstallError = uint8
+
+// Snapshot payload
+type Snapshot struct {
+	Payload  []uint8
+	MimeType string
+}
+
+//go:wasmimport golem:api/host@1.5.0 [constructor]get-agents
+func wasm_import_constructor_get_agents(arg0 int64, arg1 int64, arg2 int32, arg3 uintptr, arg4 uint32, arg5 int32) int32
+
+func MakeGetAgents(componentId golem_core_types.ComponentId, filter witTypes.Option[AgentAnyFilter], precise bool) *GetAgents {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	var option int32
+	var option7 uintptr
+	var option8 uint32
+	switch filter.Tag() {
+	case witTypes.OptionNone:
+
+		option = int32(0)
+		option7 = 0
+		option8 = 0
+	case witTypes.OptionSome:
+		payload := filter.Some()
+		slice4 := (payload).Filters
+		length6 := uint32(len(slice4))
+		result5 := witRuntime.Allocate(pinner, uintptr(length6*(2*4)), 4)
+		for index, element := range slice4 {
+			base := unsafe.Add(result5, index*(2*4))
+			slice := (element).Filters
+			length := uint32(len(slice))
+			result := witRuntime.Allocate(pinner, uintptr(length*(16+4*4)), 8)
+			for index, element := range slice {
+				base := unsafe.Add(result, index*(16+4*4))
+
+				switch element.Tag() {
+				case AgentPropertyFilterName:
+					payload := element.Name()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Comparator))
+					utf8 := unsafe.Pointer(unsafe.StringData((payload).Value))
+					pinner.Pin(utf8)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len((payload).Value)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf8)))
+
+				case AgentPropertyFilterStatus:
+					payload := element.Status()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Comparator))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Value))
+
+				case AgentPropertyFilterVersion:
+					payload := element.Version()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Comparator))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).Value)
+
+				case AgentPropertyFilterCreatedAt:
+					payload := element.CreatedAt()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Comparator))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).Value)
+
+				case AgentPropertyFilterEnv:
+					payload := element.Env()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+					utf80 := unsafe.Pointer(unsafe.StringData((payload).Name))
+					pinner.Pin(utf80)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32((payload).Comparator))
+					utf81 := unsafe.Pointer(unsafe.StringData((payload).Value))
+					pinner.Pin(utf81)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len((payload).Value)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf81)))
+
+				case AgentPropertyFilterConfig:
+					payload := element.Config()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+					utf82 := unsafe.Pointer(unsafe.StringData((payload).Name))
+					pinner.Pin(utf82)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf82)))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32((payload).Comparator))
+					utf83 := unsafe.Pointer(unsafe.StringData((payload).Value))
+					pinner.Pin(utf83)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len((payload).Value)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf83)))
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(result)))
+
+		}
+
+		option = int32(1)
+		option7 = uintptr(result5)
+		option8 = length6
+	default:
+		panic("unreachable")
+	}
+	var result9 int32
+	if precise {
+		result9 = 1
+	} else {
+		result9 = 0
+	}
+	result10 := wasm_import_constructor_get_agents(int64(((componentId).Uuid).HighBits), int64(((componentId).Uuid).LowBits), option, option7, option8, result9)
+	return GetAgentsFromOwnHandle(int32(uintptr(result10)))
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 [method]get-agents.get-next
+func wasm_import_method_get_agents_get_next(arg0 int32, arg1 uintptr)
+
+func (self *GetAgents) GetNext() witTypes.Option[[]AgentMetadata] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_method_get_agents_get_next((self).Handle(), returnArea)
+	var option witTypes.Option[[]AgentMetadata]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[[]AgentMetadata]()
+	case 1:
+		result7 := make([]AgentMetadata, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(56+8*4))
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))))
+			result := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))), index*(2*4))
+				value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+				result = append(result, value0)
+			}
+
+			result3 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 5*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 5*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))))), index*(4*4))
+				value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+				value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+				result3 = append(result3, witTypes.Tuple2[string, string]{value1, value2})
+			}
+
+			result6 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 7*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 7*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 6*4))))), index*(4*4))
+				value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+				value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+				result6 = append(result6, witTypes.Tuple2[string, string]{value4, value5})
+			}
+
+			result7 = append(result7, AgentMetadata{golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))}}, value}, result, result3, result6, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 8*4))))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 8*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))), EnvironmentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))}}})
+		}
+
+		option = witTypes.Some[[]AgentMetadata](result7)
+	default:
+		panic("unreachable")
+	}
+	result8 := option
+	return result8
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 [async-lower][method]get-promise-result.get
+func wasm_import_method_get_promise_result_get(arg0 int32, arg1 uintptr) int32
+
+func (self *GetPromiseResult) Get() []uint8 {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+
+	witAsync.SubtaskWait(uint32(wasm_import_method_get_promise_result_get((self).Handle(), returnArea)))
+	value := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+
+	return value
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 create-promise
+func wasm_import_create_promise(arg0 uintptr)
+
+func CreatePromise() golem_core_types.PromiseId {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (24 + 2*4), 8))
+	wasm_import_create_promise(returnArea)
+	value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 1*4))))
+	result := golem_core_types.PromiseId{golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 0))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8)))}}, value}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4))))}
+	return result
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 get-promise
+func wasm_import_get_promise(arg0 int64, arg1 int64, arg2 uintptr, arg3 uint32, arg4 int64) int32
+
+func GetPromise(promiseId golem_core_types.PromiseId) *GetPromiseResult {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData(((promiseId).AgentId).AgentId))
+	pinner.Pin(utf8)
+	result := wasm_import_get_promise(int64(((((promiseId).AgentId).ComponentId).Uuid).HighBits), int64(((((promiseId).AgentId).ComponentId).Uuid).LowBits), uintptr(utf8), uint32(len(((promiseId).AgentId).AgentId)), int64((promiseId).OplogIdx))
+	return GetPromiseResultFromOwnHandle(int32(uintptr(result)))
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 complete-promise
+func wasm_import_complete_promise(arg0 int64, arg1 int64, arg2 uintptr, arg3 uint32, arg4 int64, arg5 uintptr, arg6 uint32) int32
+
+func CompletePromise(promiseId golem_core_types.PromiseId, data []uint8) bool {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData(((promiseId).AgentId).AgentId))
+	pinner.Pin(utf8)
+	data0 := unsafe.Pointer(unsafe.SliceData(data))
+	pinner.Pin(data0)
+	result := wasm_import_complete_promise(int64(((((promiseId).AgentId).ComponentId).Uuid).HighBits), int64(((((promiseId).AgentId).ComponentId).Uuid).LowBits), uintptr(utf8), uint32(len(((promiseId).AgentId).AgentId)), int64((promiseId).OplogIdx), uintptr(data0), uint32(len(data)))
+	return (result != 0)
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 get-oplog-index
+func wasm_import_get_oplog_index() int64
+
+func GetOplogIndex() uint64 {
+
+	result := wasm_import_get_oplog_index()
+	return uint64(result)
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 set-oplog-index
+func wasm_import_set_oplog_index(arg0 int64)
+
+func SetOplogIndex(oplogIdx uint64) {
+
+	wasm_import_set_oplog_index(int64(oplogIdx))
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 oplog-commit
+func wasm_import_oplog_commit(arg0 int32)
+
+func OplogCommit(replicas uint8) {
+
+	wasm_import_oplog_commit(int32(replicas))
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 mark-begin-operation
+func wasm_import_mark_begin_operation() int64
+
+func MarkBeginOperation() uint64 {
+
+	result := wasm_import_mark_begin_operation()
+	return uint64(result)
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 mark-end-operation
+func wasm_import_mark_end_operation(arg0 int64)
+
+func MarkEndOperation(begin uint64) {
+
+	wasm_import_mark_end_operation(int64(begin))
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 trap
+func wasm_import_trap(arg0 uintptr, arg1 uint32)
+
+func Trap(reason string) {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData(reason))
+	pinner.Pin(utf8)
+	wasm_import_trap(uintptr(utf8), uint32(len(reason)))
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 get-oplog-persistence-level
+func wasm_import_get_oplog_persistence_level() int32
+
+func GetOplogPersistenceLevel() PersistenceLevel {
+
+	result := wasm_import_get_oplog_persistence_level()
+	var variant PersistenceLevel
+	switch result {
+	case 0:
+
+		variant = MakePersistenceLevelPersistNothing()
+
+	case 1:
+
+		variant = MakePersistenceLevelPersistRemoteSideEffects()
+
+	case 2:
+
+		variant = MakePersistenceLevelSmart()
+
+	default:
+		panic("unreachable")
+	}
+	return variant
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 set-oplog-persistence-level
+func wasm_import_set_oplog_persistence_level(arg0 int32)
+
+func SetOplogPersistenceLevel(newPersistenceLevel PersistenceLevel) {
+
+	var variant int32
+	switch newPersistenceLevel.Tag() {
+	case PersistenceLevelPersistNothing:
+
+		variant = int32(0)
+
+	case PersistenceLevelPersistRemoteSideEffects:
+
+		variant = int32(1)
+
+	case PersistenceLevelSmart:
+
+		variant = int32(2)
+
+	default:
+		panic("unreachable")
+	}
+	wasm_import_set_oplog_persistence_level(variant)
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 get-idempotence-mode
+func wasm_import_get_idempotence_mode() int32
+
+func GetIdempotenceMode() bool {
+
+	result := wasm_import_get_idempotence_mode()
+	return (result != 0)
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 set-idempotence-mode
+func wasm_import_set_idempotence_mode(arg0 int32)
+
+func SetIdempotenceMode(idempotent bool) {
+
+	var result int32
+	if idempotent {
+		result = 1
+	} else {
+		result = 0
+	}
+	wasm_import_set_idempotence_mode(result)
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 generate-idempotency-key
+func wasm_import_generate_idempotency_key(arg0 uintptr)
+
+func GenerateIdempotencyKey() golem_core_types.Uuid {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 16, 8))
+	wasm_import_generate_idempotency_key(returnArea)
+	result := golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 0))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8)))}
+	return result
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 self-card
+func wasm_import_self_card(arg0 uintptr)
+
+func SelfCard() witTypes.Option[Card] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 24, 8))
+	wasm_import_self_card(returnArea)
+	var option witTypes.Option[Card]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[Card]()
+	case 1:
+
+		option = witTypes.Some[Card](Card{golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)))}}})
+	default:
+		panic("unreachable")
+	}
+	result := option
+	return result
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 derive-card
+func wasm_import_derive_card(arg0 int64, arg1 int64, arg2 uintptr)
+
+func DeriveCard(card Card) witTypes.Result[Card, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 24, 8))
+	wasm_import_derive_card(int64((((card).CardId).Uuid).HighBits), int64((((card).CardId).Uuid).LowBits), returnArea)
+	var result witTypes.Result[Card, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[Card, string](Card{golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)))}}})
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		result = witTypes.Err[Card, string](value)
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 install-card
+func wasm_import_install_card(arg0 int64, arg1 int64, arg2 uintptr)
+
+func InstallCard(card Card) witTypes.Result[witTypes.Unit, CardInstallError] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 2, 1))
+	wasm_import_install_card(int64((((card).CardId).Uuid).HighBits), int64((((card).CardId).Uuid).LowBits), returnArea)
+	var result witTypes.Result[witTypes.Unit, CardInstallError]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, CardInstallError](witTypes.Unit{})
+	case 1:
+
+		result = witTypes.Err[witTypes.Unit, CardInstallError](uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 1)))))
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 update-agent
+func wasm_import_update_agent(arg0 int64, arg1 int64, arg2 uintptr, arg3 uint32, arg4 int64, arg5 int32)
+
+func UpdateAgent(agentId golem_core_types.AgentId, targetRevision uint64, mode UpdateMode) {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData((agentId).AgentId))
+	pinner.Pin(utf8)
+	wasm_import_update_agent(int64((((agentId).ComponentId).Uuid).HighBits), int64((((agentId).ComponentId).Uuid).LowBits), uintptr(utf8), uint32(len((agentId).AgentId)), int64(targetRevision), int32(mode))
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 get-self-metadata
+func wasm_import_get_self_metadata(arg0 uintptr)
+
+func GetSelfMetadata() AgentMetadata {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (56 + 8*4), 8))
+	wasm_import_get_self_metadata(returnArea)
+	value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 1*4))))
+	result := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 3*4))))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 3*4)))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4))))), index*(2*4))
+		value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+		result = append(result, value0)
+	}
+
+	result3 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 5*4))))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 5*4)))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 4*4))))), index*(4*4))
+		value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+		value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+		result3 = append(result3, witTypes.Tuple2[string, string]{value1, value2})
+	}
+
+	result6 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 7*4))))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 7*4)))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 6*4))))), index*(4*4))
+		value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+		value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+		result6 = append(result6, witTypes.Tuple2[string, string]{value4, value5})
+	}
+
+	result7 := AgentMetadata{golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 0))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8)))}}, value}, result, result3, result6, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 8*4))))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 8*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (32 + 8*4)))), EnvironmentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (40 + 8*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (48 + 8*4))))}}}
+	return result7
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 get-agent-metadata
+func wasm_import_get_agent_metadata(arg0 int64, arg1 int64, arg2 uintptr, arg3 uint32, arg4 uintptr)
+
+func GetAgentMetadata(agentId golem_core_types.AgentId) witTypes.Option[AgentMetadata] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (64 + 8*4), 8))
+	utf8 := unsafe.Pointer(unsafe.StringData((agentId).AgentId))
+	pinner.Pin(utf8)
+	wasm_import_get_agent_metadata(int64((((agentId).ComponentId).Uuid).HighBits), int64((((agentId).ComponentId).Uuid).LowBits), uintptr(utf8), uint32(len((agentId).AgentId)), returnArea)
+	var option witTypes.Option[AgentMetadata]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[AgentMetadata]()
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 1*4))))
+		result := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 3*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 3*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 2*4))))), index*(2*4))
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+			result = append(result, value0)
+		}
+
+		result3 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 5*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 5*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 4*4))))), index*(4*4))
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+			result3 = append(result3, witTypes.Tuple2[string, string]{value1, value2})
+		}
+
+		result6 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 7*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 7*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 6*4))))), index*(4*4))
+			value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+			result6 = append(result6, witTypes.Tuple2[string, string]{value4, value5})
+		}
+
+		option = witTypes.Some[AgentMetadata](AgentMetadata{golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)))}}, value}, result, result3, result6, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 8*4))))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (32 + 8*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (40 + 8*4)))), EnvironmentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (48 + 8*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (56 + 8*4))))}}})
+	default:
+		panic("unreachable")
+	}
+	result7 := option
+	return result7
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 fork-agent
+func wasm_import_fork_agent(arg0 int64, arg1 int64, arg2 uintptr, arg3 uint32, arg4 int64, arg5 int64, arg6 uintptr, arg7 uint32, arg8 int64)
+
+func ForkAgent(sourceAgentId golem_core_types.AgentId, targetAgentId golem_core_types.AgentId, oplogIdxCutOff uint64) {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData((sourceAgentId).AgentId))
+	pinner.Pin(utf8)
+	utf80 := unsafe.Pointer(unsafe.StringData((targetAgentId).AgentId))
+	pinner.Pin(utf80)
+	wasm_import_fork_agent(int64((((sourceAgentId).ComponentId).Uuid).HighBits), int64((((sourceAgentId).ComponentId).Uuid).LowBits), uintptr(utf8), uint32(len((sourceAgentId).AgentId)), int64((((targetAgentId).ComponentId).Uuid).HighBits), int64((((targetAgentId).ComponentId).Uuid).LowBits), uintptr(utf80), uint32(len((targetAgentId).AgentId)), int64(oplogIdxCutOff))
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 revert-agent
+func wasm_import_revert_agent(arg0 int64, arg1 int64, arg2 uintptr, arg3 uint32, arg4 int32, arg5 int64)
+
+func RevertAgent(agentId golem_core_types.AgentId, revertTarget RevertAgentTarget) {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData((agentId).AgentId))
+	pinner.Pin(utf8)
+	var variant int32
+	var variant0 int64
+	switch revertTarget.Tag() {
+	case RevertAgentTargetRevertToOplogIndex:
+		payload := revertTarget.RevertToOplogIndex()
+
+		variant = int32(0)
+		variant0 = int64(payload)
+
+	case RevertAgentTargetRevertLastInvocations:
+		payload := revertTarget.RevertLastInvocations()
+
+		variant = int32(1)
+		variant0 = int64(payload)
+
+	default:
+		panic("unreachable")
+	}
+	wasm_import_revert_agent(int64((((agentId).ComponentId).Uuid).HighBits), int64((((agentId).ComponentId).Uuid).LowBits), uintptr(utf8), uint32(len((agentId).AgentId)), variant, variant0)
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 resolve-component-id
+func wasm_import_resolve_component_id(arg0 uintptr, arg1 uint32, arg2 uintptr)
+
+func ResolveComponentId(componentReference string) witTypes.Option[golem_core_types.ComponentId] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 24, 8))
+	utf8 := unsafe.Pointer(unsafe.StringData(componentReference))
+	pinner.Pin(utf8)
+	wasm_import_resolve_component_id(uintptr(utf8), uint32(len(componentReference)), returnArea)
+	var option witTypes.Option[golem_core_types.ComponentId]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[golem_core_types.ComponentId]()
+	case 1:
+
+		option = witTypes.Some[golem_core_types.ComponentId](golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)))}})
+	default:
+		panic("unreachable")
+	}
+	result := option
+	return result
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 resolve-agent-id
+func wasm_import_resolve_agent_id(arg0 uintptr, arg1 uint32, arg2 uintptr, arg3 uint32, arg4 uintptr)
+
+func ResolveAgentId(componentReference string, agentName string) witTypes.Option[golem_core_types.AgentId] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (24 + 2*4), 8))
+	utf8 := unsafe.Pointer(unsafe.StringData(componentReference))
+	pinner.Pin(utf8)
+	utf80 := unsafe.Pointer(unsafe.StringData(agentName))
+	pinner.Pin(utf80)
+	wasm_import_resolve_agent_id(uintptr(utf8), uint32(len(componentReference)), uintptr(utf80), uint32(len(agentName)), returnArea)
+	var option witTypes.Option[golem_core_types.AgentId]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[golem_core_types.AgentId]()
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 1*4))))
+
+		option = witTypes.Some[golem_core_types.AgentId](golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)))}}, value})
+	default:
+		panic("unreachable")
+	}
+	result := option
+	return result
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 resolve-agent-id-strict
+func wasm_import_resolve_agent_id_strict(arg0 uintptr, arg1 uint32, arg2 uintptr, arg3 uint32, arg4 uintptr)
+
+func ResolveAgentIdStrict(componentReference string, agentName string) witTypes.Option[golem_core_types.AgentId] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (24 + 2*4), 8))
+	utf8 := unsafe.Pointer(unsafe.StringData(componentReference))
+	pinner.Pin(utf8)
+	utf80 := unsafe.Pointer(unsafe.StringData(agentName))
+	pinner.Pin(utf80)
+	wasm_import_resolve_agent_id_strict(uintptr(utf8), uint32(len(componentReference)), uintptr(utf80), uint32(len(agentName)), returnArea)
+	var option witTypes.Option[golem_core_types.AgentId]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[golem_core_types.AgentId]()
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 1*4))))
+
+		option = witTypes.Some[golem_core_types.AgentId](golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)))}}, value})
+	default:
+		panic("unreachable")
+	}
+	result := option
+	return result
+
+}
+
+//go:wasmimport golem:api/host@1.5.0 fork
+func wasm_import_fork(arg0 uintptr)
+
+func Fork() ForkResult {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 24, 8))
+	wasm_import_fork(returnArea)
+	var variant ForkResult
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		variant = MakeForkResultOriginal(ForkDetails{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)))}})
+
+	case 1:
+
+		variant = MakeForkResultForked(ForkDetails{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)))}})
+
+	default:
+		panic("unreachable")
+	}
+	result := variant
+	return result
+
+}
diff --git a/sdks/go/golem/internal/wit/golem_api_load_snapshot/empty.s b/sdks/go/golem/internal/wit/golem_api_load_snapshot/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_api_load_snapshot/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_api_load_snapshot/wit_bindings.go b/sdks/go/golem/internal/wit/golem_api_load_snapshot/wit_bindings.go
new file mode 100644
index 0000000000..23d10c78ff
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_api_load_snapshot/wit_bindings.go
@@ -0,0 +1,38 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_api_load_snapshot
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_host"
+)
+
+type Snapshot = golem_api_host.Snapshot
diff --git a/sdks/go/golem/internal/wit/golem_api_oplog/empty.s b/sdks/go/golem/internal/wit/golem_api_oplog/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_api_oplog/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_api_oplog/wit_bindings.go b/sdks/go/golem/internal/wit/golem_api_oplog/wit_bindings.go
new file mode 100644
index 0000000000..4914468dd7
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_api_oplog/wit_bindings.go
@@ -0,0 +1,72221 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_api_oplog
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_context"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_host"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_retry"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_system_clock"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type Datetime = wasi_clocks_0_3_0_system_clock.Instant
+type AccountId = golem_core_types.AccountId
+type CardId = golem_core_types.CardId
+type SchemaValueTree = golem_core_types.SchemaValueTree
+type TypedSchemaValue = golem_core_types.TypedSchemaValue
+type ComponentRevision = uint64
+type OplogIndex = uint64
+type PersistenceLevel = golem_api_host.PersistenceLevel
+type EnvironmentId = golem_api_host.EnvironmentId
+type Uuid = golem_core_types.Uuid
+type AgentId = golem_core_types.AgentId
+type Snapshot = golem_api_host.Snapshot
+type Duration = uint64
+type Attribute = golem_api_context.Attribute
+type AttributeValue = golem_api_context.AttributeValue
+type SpanId = string
+type TraceId = string
+type RetryPredicate = golem_api_retry.RetryPredicate
+type RetryPolicy = golem_api_retry.RetryPolicy
+type NamedRetryPolicy = golem_api_retry.NamedRetryPolicy
+
+const (
+	AgentModeDurable   uint8 = 0
+	AgentModeEphemeral uint8 = 1
+)
+
+// Whether an agent is durable (persistent oplog) or ephemeral.
+// This mirrors the agent-mode enum in golem:agent/common@1.5.0; it is duplicated here to avoid
+// a circular WIT package dependency between golem:api and golem:agent.
+type AgentMode = uint8
+
+// Index into a retry-policy-state's node list
+type StateNodeIndex = int32
+
+type CountBoxState struct {
+	Attempts uint32
+	Inner    int32
+}
+
+type AndThenState struct {
+	Left    int32
+	Right   int32
+	OnRight bool
+}
+
+type PairState struct {
+	Left  int32
+	Right int32
+}
+
+const (
+	// Counter-based state (e.g. periodic, exponential, fibonacci).
+	StateNodeCounter uint8 = 0
+	// Terminal state — policy has given up.
+	StateNodeTerminal uint8 = 1
+	// Wrapper state delegating to an inner policy state.
+	StateNodeWrapper uint8 = 2
+	// Count-box state with attempt tracking.
+	StateNodeCountBox uint8 = 3
+	// And-then sequential composition state.
+	StateNodeAndThen uint8 = 4
+	// Pair state for union/intersect composition.
+	StateNodePair uint8 = 5
+)
+
+type StateNode struct {
+	tag   uint8
+	value any
+}
+
+func (self StateNode) Tag() uint8 {
+	return self.tag
+}
+
+func (self StateNode) Counter() uint32 {
+	if self.tag != StateNodeCounter {
+		panic("tag mismatch")
+	}
+	return self.value.(uint32)
+}
+func (self StateNode) Wrapper() int32 {
+	if self.tag != StateNodeWrapper {
+		panic("tag mismatch")
+	}
+	return self.value.(int32)
+}
+func (self StateNode) CountBox() CountBoxState {
+	if self.tag != StateNodeCountBox {
+		panic("tag mismatch")
+	}
+	return self.value.(CountBoxState)
+}
+func (self StateNode) AndThen() AndThenState {
+	if self.tag != StateNodeAndThen {
+		panic("tag mismatch")
+	}
+	return self.value.(AndThenState)
+}
+func (self StateNode) Pair() PairState {
+	if self.tag != StateNodePair {
+		panic("tag mismatch")
+	}
+	return self.value.(PairState)
+}
+
+func MakeStateNodeCounter(value uint32) StateNode {
+	return StateNode{StateNodeCounter, value}
+}
+func MakeStateNodeTerminal() StateNode {
+	return StateNode{StateNodeTerminal, nil}
+}
+func MakeStateNodeWrapper(value int32) StateNode {
+	return StateNode{StateNodeWrapper, value}
+}
+func MakeStateNodeCountBox(value CountBoxState) StateNode {
+	return StateNode{StateNodeCountBox, value}
+}
+func MakeStateNodeAndThen(value AndThenState) StateNode {
+	return StateNode{StateNodeAndThen, value}
+}
+func MakeStateNodePair(value PairState) StateNode {
+	return StateNode{StateNodePair, value}
+}
+
+// Persistent state of a retry policy across retry attempts.
+// Root is nodes[0]. Children referenced by state-node-index.
+type RetryPolicyState struct {
+	Nodes []StateNode
+}
+
+type EnvironmentPluginGrantId struct {
+	Uuid golem_core_types.Uuid
+}
+
+const (
+	// The side-effect reads from the agent's local state (for example local file system,
+	// random generator, etc.)
+	WrappedFunctionTypeReadLocal uint8 = 0
+	// The side-effect writes to the agent's local state (for example local file system)
+	WrappedFunctionTypeWriteLocal uint8 = 1
+	// The side-effect reads from external state (for example a key-value store)
+	WrappedFunctionTypeReadRemote uint8 = 2
+	// The side-effect manipulates external state (for example an RPC call)
+	WrappedFunctionTypeWriteRemote uint8 = 3
+	// The side-effect manipulates external state through multiple invoked functions (for example
+	// a HTTP request where reading the response involves multiple host function calls)
+	//
+	// On the first invocation of the batch, the parameter should be `None` - this triggers
+	// writing a scope `Start` entry in the oplog. Followup invocations should contain this
+	// entry's index as the parameter so their host-call `Start` entries can point back to the
+	// scope. In batched remote writes it is the caller's responsibility to manually write the
+	// matching scope `End` entry (using `end_function`) when the operation is completed.
+	WrappedFunctionTypeWriteRemoteBatched     uint8 = 4
+	WrappedFunctionTypeWriteRemoteTransaction uint8 = 5
+)
+
+type WrappedFunctionType struct {
+	tag   uint8
+	value any
+}
+
+func (self WrappedFunctionType) Tag() uint8 {
+	return self.tag
+}
+
+func (self WrappedFunctionType) WriteRemoteBatched() witTypes.Option[uint64] {
+	if self.tag != WrappedFunctionTypeWriteRemoteBatched {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[uint64])
+}
+func (self WrappedFunctionType) WriteRemoteTransaction() witTypes.Option[uint64] {
+	if self.tag != WrappedFunctionTypeWriteRemoteTransaction {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[uint64])
+}
+
+func MakeWrappedFunctionTypeReadLocal() WrappedFunctionType {
+	return WrappedFunctionType{WrappedFunctionTypeReadLocal, nil}
+}
+func MakeWrappedFunctionTypeWriteLocal() WrappedFunctionType {
+	return WrappedFunctionType{WrappedFunctionTypeWriteLocal, nil}
+}
+func MakeWrappedFunctionTypeReadRemote() WrappedFunctionType {
+	return WrappedFunctionType{WrappedFunctionTypeReadRemote, nil}
+}
+func MakeWrappedFunctionTypeWriteRemote() WrappedFunctionType {
+	return WrappedFunctionType{WrappedFunctionTypeWriteRemote, nil}
+}
+func MakeWrappedFunctionTypeWriteRemoteBatched(value witTypes.Option[uint64]) WrappedFunctionType {
+	return WrappedFunctionType{WrappedFunctionTypeWriteRemoteBatched, value}
+}
+func MakeWrappedFunctionTypeWriteRemoteTransaction(value witTypes.Option[uint64]) WrappedFunctionType {
+	return WrappedFunctionType{WrappedFunctionTypeWriteRemoteTransaction, value}
+}
+
+type PluginInstallationDescription struct {
+	EnvironmentPluginGrantId EnvironmentPluginGrantId
+	PluginPriority           int32
+	PluginName               string
+	PluginVersion            string
+	Parameters               []witTypes.Tuple2[string, string]
+}
+
+type RawLocalAgentConfigEntry struct {
+	Path  []string
+	Value golem_core_types.SchemaValueTree
+}
+
+type LocalAgentConfigEntry struct {
+	Path  []string
+	Value golem_core_types.TypedSchemaValue
+}
+
+type CreateParameters struct {
+	Timestamp                    wasi_clocks_0_3_0_system_clock.Instant
+	AgentId                      golem_core_types.AgentId
+	AgentMode                    AgentMode
+	ComponentRevision            uint64
+	Env                          []witTypes.Tuple2[string, string]
+	CreatedBy                    golem_core_types.AccountId
+	EnvironmentId                golem_api_host.EnvironmentId
+	Parent                       witTypes.Option[golem_core_types.AgentId]
+	ComponentSize                uint64
+	InitialTotalLinearMemorySize uint64
+	InitialActivePlugins         []PluginInstallationDescription
+	LocalAgentConfig             []LocalAgentConfigEntry
+	OriginalPhantomId            witTypes.Option[golem_core_types.Uuid]
+	InstanceId                   golem_core_types.Uuid
+}
+
+// Parameters of an enriched durable host-call `start` entry.
+//
+// The recorded `request` payload of every durable host call — including
+// durable P3 async calls such as HTTP send/consume-body, sockets, keyvalue,
+// and blobstore operations — surfaces as a generic `typed-schema-value`
+// tree, identified by `function-name`; there are no per-interface named WIT
+// variants for the payload shapes.
+type StartParameters struct {
+	Timestamp           wasi_clocks_0_3_0_system_clock.Instant
+	ParentStartIndex    witTypes.Option[uint64]
+	FunctionName        string
+	Request             witTypes.Option[golem_core_types.TypedSchemaValue]
+	DurableFunctionType WrappedFunctionType
+}
+
+// Parameters of an enriched durable host-call `end` entry. Like the
+// `start` `request`, the recorded `response` payload surfaces as a generic
+// `typed-schema-value` tree (no per-interface named WIT variants).
+type EndParameters struct {
+	Timestamp    wasi_clocks_0_3_0_system_clock.Instant
+	StartIndex   uint64
+	Response     witTypes.Option[golem_core_types.TypedSchemaValue]
+	ForcedCommit bool
+}
+
+// Parameters of an enriched durable host-call `cancelled` entry. Like the
+// `start` `request`, the optional recorded `partial` result surfaces as a
+// generic `typed-schema-value` tree (no per-interface named WIT variants).
+type CancelledParameters struct {
+	Timestamp  wasi_clocks_0_3_0_system_clock.Instant
+	StartIndex uint64
+	Partial    witTypes.Option[golem_core_types.TypedSchemaValue]
+}
+
+// Parameters of a `completion-discarded` entry: the durable host call started at
+// `start-index` completed successfully (its `end` entry was persisted) but the response
+// was never delivered to the agent, because the agent dropped the call's completion
+// future after the `end` was already recorded.
+type CompletionDiscardedParameters struct {
+	Timestamp  wasi_clocks_0_3_0_system_clock.Instant
+	StartIndex uint64
+}
+
+type LocalSpanData struct {
+	SpanId string
+	Start  wasi_clocks_0_3_0_system_clock.Instant
+	Parent witTypes.Option[string]
+	// Optionally an index of the invocation-context field within agent-invocation
+	LinkedContext witTypes.Option[uint64]
+	Attributes    []golem_api_context.Attribute
+	Inherited     bool
+}
+
+type ExternalSpanData struct {
+	SpanId string
+}
+
+const (
+	SpanDataLocalSpan    uint8 = 0
+	SpanDataExternalSpan uint8 = 1
+)
+
+type SpanData struct {
+	tag   uint8
+	value any
+}
+
+func (self SpanData) Tag() uint8 {
+	return self.tag
+}
+
+func (self SpanData) LocalSpan() LocalSpanData {
+	if self.tag != SpanDataLocalSpan {
+		panic("tag mismatch")
+	}
+	return self.value.(LocalSpanData)
+}
+func (self SpanData) ExternalSpan() ExternalSpanData {
+	if self.tag != SpanDataExternalSpan {
+		panic("tag mismatch")
+	}
+	return self.value.(ExternalSpanData)
+}
+
+func MakeSpanDataLocalSpan(value LocalSpanData) SpanData {
+	return SpanData{SpanDataLocalSpan, value}
+}
+func MakeSpanDataExternalSpan(value ExternalSpanData) SpanData {
+	return SpanData{SpanDataExternalSpan, value}
+}
+
+type ErrorParameters struct {
+	Timestamp          wasi_clocks_0_3_0_system_clock.Instant
+	Error              string
+	RetryFrom          uint64
+	InsideAtomicRegion bool
+	// Persistent retry policy state, if a semantic retry policy is active.
+	RetryPolicyState witTypes.Option[RetryPolicyState]
+}
+
+type OplogRegion struct {
+	Start uint64
+	End   uint64
+}
+
+type JumpParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	Jump      OplogRegion
+}
+
+// Parameters for a set-retry-policy oplog entry.
+type SetRetryPolicyParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	Policy    golem_api_retry.NamedRetryPolicy
+}
+
+// Parameters for a remove-retry-policy oplog entry.
+type RemoveRetryPolicyParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	Name      string
+}
+
+type QueuedCardEventInstall struct {
+	CardId golem_core_types.CardId
+}
+
+type QueuedCardEventRevoke struct {
+	CardId golem_core_types.CardId
+}
+
+const (
+	QueuedCardEventInstallTag uint8 = 0
+	QueuedCardEventRevokeTag  uint8 = 1
+)
+
+type QueuedCardEvent struct {
+	tag   uint8
+	value any
+}
+
+func (self QueuedCardEvent) Tag() uint8 {
+	return self.tag
+}
+
+func (self QueuedCardEvent) Install() QueuedCardEventInstall {
+	if self.tag != QueuedCardEventInstallTag {
+		panic("tag mismatch")
+	}
+	return self.value.(QueuedCardEventInstall)
+}
+func (self QueuedCardEvent) Revoke() QueuedCardEventRevoke {
+	if self.tag != QueuedCardEventRevokeTag {
+		panic("tag mismatch")
+	}
+	return self.value.(QueuedCardEventRevoke)
+}
+
+func MakeQueuedCardEventInstall(value QueuedCardEventInstall) QueuedCardEvent {
+	return QueuedCardEvent{QueuedCardEventInstallTag, value}
+}
+func MakeQueuedCardEventRevoke(value QueuedCardEventRevoke) QueuedCardEvent {
+	return QueuedCardEvent{QueuedCardEventRevokeTag, value}
+}
+
+// Parameters for a card-event-queued oplog entry.
+type CardEventQueuedParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	Event     QueuedCardEvent
+}
+
+// Parameters for a card-installed oplog entry.
+type CardInstalledParameters struct {
+	Timestamp        wasi_clocks_0_3_0_system_clock.Instant
+	QueuedEventIndex witTypes.Option[uint64]
+	CardId           golem_core_types.CardId
+}
+
+// Raw parameters for a card-installed oplog entry.
+type RawCardInstalledParameters struct {
+	Timestamp        wasi_clocks_0_3_0_system_clock.Instant
+	QueuedEventIndex witTypes.Option[uint64]
+	Card             []uint8
+}
+
+const (
+	CardInstallFailureCardRevoked       uint8 = 0
+	CardInstallFailureNotFound          uint8 = 1
+	CardInstallFailureRecipientMismatch uint8 = 2
+	CardInstallFailureNotPermitted      uint8 = 3
+)
+
+type CardInstallFailure = uint8
+
+// Parameters for a card-install-failed oplog entry.
+type CardInstallFailedParameters struct {
+	Timestamp        wasi_clocks_0_3_0_system_clock.Instant
+	QueuedEventIndex uint64
+	CardId           golem_core_types.CardId
+	Reason           CardInstallFailure
+}
+
+// Parameters for a card-revoked oplog entry.
+type CardRevokedParameters struct {
+	Timestamp        wasi_clocks_0_3_0_system_clock.Instant
+	QueuedEventIndex uint64
+	CardId           golem_core_types.CardId
+}
+
+// Parameters for a card-expired oplog entry.
+type CardExpiredParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	CardId    golem_core_types.CardId
+}
+
+const (
+	// A frame of the outgoing request body of a P3 HTTP client send.
+	HostStreamKindP3HttpRequestBody uint8 = 0
+)
+
+// Identifies which host-owned stream a host-stream-frame oplog entry belongs to.
+// The kind determines how the entry's payload is interpreted.
+type HostStreamKind = uint8
+
+// Parameters for a host-stream-frame oplog entry: a durably recorded frame of a
+// host-owned stream (e.g. the outgoing request body of a P3 HTTP client send),
+// attached to the durable host call identified by its start entry's index.
+type HostStreamFrameParameters struct {
+	Timestamp        wasi_clocks_0_3_0_system_clock.Instant
+	ParentStartIndex uint64
+	Kind             HostStreamKind
+	Payload          golem_core_types.TypedSchemaValue
+}
+
+type EndAtomicRegionParameters struct {
+	Timestamp  wasi_clocks_0_3_0_system_clock.Instant
+	BeginIndex uint64
+}
+
+type AgentInitializationParameters struct {
+	IdempotencyKey        string
+	ConstructorParameters golem_core_types.TypedSchemaValue
+	TraceId               string
+	TraceStates           []string
+	InvocationContext     [][]SpanData
+}
+
+type AgentMethodInvocationParameters struct {
+	IdempotencyKey    string
+	MethodName        string
+	FunctionInput     golem_core_types.TypedSchemaValue
+	TraceId           string
+	TraceStates       []string
+	InvocationContext [][]SpanData
+}
+
+type ProcessOplogEntriesParameters struct {
+	IdempotencyKey string
+}
+
+type ManualUpdateParameters struct {
+	TargetRevision uint64
+}
+
+type AgentInvocationOutputParameters struct {
+	Output golem_core_types.TypedSchemaValue
+}
+
+type FallibleResultParameters struct {
+	Error witTypes.Option[string]
+}
+
+const (
+	// Automatic update by replaying the oplog on the new version
+	UpdateDescriptionAutoUpdate uint8 = 0
+	// Custom update by loading a given snapshot on the new version
+	UpdateDescriptionSnapshotBased uint8 = 1
+)
+
+type UpdateDescription struct {
+	tag   uint8
+	value any
+}
+
+func (self UpdateDescription) Tag() uint8 {
+	return self.tag
+}
+
+func (self UpdateDescription) SnapshotBased() golem_api_host.Snapshot {
+	if self.tag != UpdateDescriptionSnapshotBased {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_api_host.Snapshot)
+}
+
+func MakeUpdateDescriptionAutoUpdate() UpdateDescription {
+	return UpdateDescription{UpdateDescriptionAutoUpdate, nil}
+}
+func MakeUpdateDescriptionSnapshotBased(value golem_api_host.Snapshot) UpdateDescription {
+	return UpdateDescription{UpdateDescriptionSnapshotBased, value}
+}
+
+type PendingUpdateParameters struct {
+	Timestamp      wasi_clocks_0_3_0_system_clock.Instant
+	TargetRevision uint64
+	Description    UpdateDescription
+}
+
+type SuccessfulUpdateParameters struct {
+	Timestamp        wasi_clocks_0_3_0_system_clock.Instant
+	TargetRevision   uint64
+	NewComponentSize uint64
+	NewActivePlugins []PluginInstallationDescription
+}
+
+type FailedUpdateParameters struct {
+	Timestamp      wasi_clocks_0_3_0_system_clock.Instant
+	TargetRevision uint64
+	Details        witTypes.Option[string]
+}
+
+type GrowMemoryParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	Delta     uint64
+}
+
+type FilesystemStorageUsageUpdateParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	Delta     int64
+}
+type AgentResourceId = uint64
+
+type CreateResourceParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	Id        uint64
+	Name      string
+	Owner     string
+}
+
+type DropResourceParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	Id        uint64
+	Name      string
+	Owner     string
+}
+
+const (
+	LogLevelStdout   uint8 = 0
+	LogLevelStderr   uint8 = 1
+	LogLevelTrace    uint8 = 2
+	LogLevelDebug    uint8 = 3
+	LogLevelInfo     uint8 = 4
+	LogLevelWarn     uint8 = 5
+	LogLevelError    uint8 = 6
+	LogLevelCritical uint8 = 7
+)
+
+type LogLevel = uint8
+
+type LogParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	Level     LogLevel
+	Context   string
+	Message   string
+}
+
+type ActivatePluginParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	Plugin    PluginInstallationDescription
+}
+
+type DeactivatePluginParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	Plugin    PluginInstallationDescription
+}
+
+type RevertParameters struct {
+	Timestamp     wasi_clocks_0_3_0_system_clock.Instant
+	DroppedRegion OplogRegion
+}
+
+type CancelPendingInvocationParameters struct {
+	Timestamp      wasi_clocks_0_3_0_system_clock.Instant
+	IdempotencyKey string
+}
+
+type StartSpanParameters struct {
+	Timestamp       wasi_clocks_0_3_0_system_clock.Instant
+	SpanId          string
+	Parent          witTypes.Option[string]
+	LinkedContextId witTypes.Option[string]
+	Attributes      []golem_api_context.Attribute
+}
+
+type FinishSpanParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	SpanId    string
+}
+
+type SetSpanAttributeParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	SpanId    string
+	Key       string
+	Value     golem_api_context.AttributeValue
+}
+
+type ChangePersistenceLevelParameters struct {
+	Timestamp        wasi_clocks_0_3_0_system_clock.Instant
+	PersistenceLevel golem_api_host.PersistenceLevel
+}
+
+type BeginRemoteTransactionParameters struct {
+	Timestamp     wasi_clocks_0_3_0_system_clock.Instant
+	TransactionId string
+}
+
+type RemoteTransactionParameters struct {
+	Timestamp  wasi_clocks_0_3_0_system_clock.Instant
+	BeginIndex uint64
+}
+
+type SnapshotData struct {
+	Data     []uint8
+	MimeType string
+}
+
+type LoadSnapshotParameters struct {
+	Snapshot SnapshotData
+}
+
+const (
+	AgentInvocationAgentInitialization   uint8 = 0
+	AgentInvocationAgentMethodInvocation uint8 = 1
+	AgentInvocationSaveSnapshot          uint8 = 2
+	AgentInvocationLoadSnapshot          uint8 = 3
+	AgentInvocationProcessOplogEntries   uint8 = 4
+	AgentInvocationManualUpdate          uint8 = 5
+)
+
+type AgentInvocation struct {
+	tag   uint8
+	value any
+}
+
+func (self AgentInvocation) Tag() uint8 {
+	return self.tag
+}
+
+func (self AgentInvocation) AgentInitialization() AgentInitializationParameters {
+	if self.tag != AgentInvocationAgentInitialization {
+		panic("tag mismatch")
+	}
+	return self.value.(AgentInitializationParameters)
+}
+func (self AgentInvocation) AgentMethodInvocation() AgentMethodInvocationParameters {
+	if self.tag != AgentInvocationAgentMethodInvocation {
+		panic("tag mismatch")
+	}
+	return self.value.(AgentMethodInvocationParameters)
+}
+func (self AgentInvocation) LoadSnapshot() LoadSnapshotParameters {
+	if self.tag != AgentInvocationLoadSnapshot {
+		panic("tag mismatch")
+	}
+	return self.value.(LoadSnapshotParameters)
+}
+func (self AgentInvocation) ProcessOplogEntries() ProcessOplogEntriesParameters {
+	if self.tag != AgentInvocationProcessOplogEntries {
+		panic("tag mismatch")
+	}
+	return self.value.(ProcessOplogEntriesParameters)
+}
+func (self AgentInvocation) ManualUpdate() ManualUpdateParameters {
+	if self.tag != AgentInvocationManualUpdate {
+		panic("tag mismatch")
+	}
+	return self.value.(ManualUpdateParameters)
+}
+
+func MakeAgentInvocationAgentInitialization(value AgentInitializationParameters) AgentInvocation {
+	return AgentInvocation{AgentInvocationAgentInitialization, value}
+}
+func MakeAgentInvocationAgentMethodInvocation(value AgentMethodInvocationParameters) AgentInvocation {
+	return AgentInvocation{AgentInvocationAgentMethodInvocation, value}
+}
+func MakeAgentInvocationSaveSnapshot() AgentInvocation {
+	return AgentInvocation{AgentInvocationSaveSnapshot, nil}
+}
+func MakeAgentInvocationLoadSnapshot(value LoadSnapshotParameters) AgentInvocation {
+	return AgentInvocation{AgentInvocationLoadSnapshot, value}
+}
+func MakeAgentInvocationProcessOplogEntries(value ProcessOplogEntriesParameters) AgentInvocation {
+	return AgentInvocation{AgentInvocationProcessOplogEntries, value}
+}
+func MakeAgentInvocationManualUpdate(value ManualUpdateParameters) AgentInvocation {
+	return AgentInvocation{AgentInvocationManualUpdate, value}
+}
+
+type AgentInvocationStartedParameters struct {
+	Timestamp  wasi_clocks_0_3_0_system_clock.Instant
+	Invocation AgentInvocation
+}
+
+type SaveSnapshotResultParameters struct {
+	Snapshot SnapshotData
+}
+
+const (
+	AgentInvocationResultAgentInitialization uint8 = 0
+	AgentInvocationResultAgentMethod         uint8 = 1
+	AgentInvocationResultManualUpdate        uint8 = 2
+	AgentInvocationResultLoadSnapshot        uint8 = 3
+	AgentInvocationResultSaveSnapshot        uint8 = 4
+	AgentInvocationResultProcessOplogEntries uint8 = 5
+)
+
+type AgentInvocationResult struct {
+	tag   uint8
+	value any
+}
+
+func (self AgentInvocationResult) Tag() uint8 {
+	return self.tag
+}
+
+func (self AgentInvocationResult) AgentInitialization() AgentInvocationOutputParameters {
+	if self.tag != AgentInvocationResultAgentInitialization {
+		panic("tag mismatch")
+	}
+	return self.value.(AgentInvocationOutputParameters)
+}
+func (self AgentInvocationResult) AgentMethod() AgentInvocationOutputParameters {
+	if self.tag != AgentInvocationResultAgentMethod {
+		panic("tag mismatch")
+	}
+	return self.value.(AgentInvocationOutputParameters)
+}
+func (self AgentInvocationResult) LoadSnapshot() FallibleResultParameters {
+	if self.tag != AgentInvocationResultLoadSnapshot {
+		panic("tag mismatch")
+	}
+	return self.value.(FallibleResultParameters)
+}
+func (self AgentInvocationResult) SaveSnapshot() SaveSnapshotResultParameters {
+	if self.tag != AgentInvocationResultSaveSnapshot {
+		panic("tag mismatch")
+	}
+	return self.value.(SaveSnapshotResultParameters)
+}
+func (self AgentInvocationResult) ProcessOplogEntries() FallibleResultParameters {
+	if self.tag != AgentInvocationResultProcessOplogEntries {
+		panic("tag mismatch")
+	}
+	return self.value.(FallibleResultParameters)
+}
+
+func MakeAgentInvocationResultAgentInitialization(value AgentInvocationOutputParameters) AgentInvocationResult {
+	return AgentInvocationResult{AgentInvocationResultAgentInitialization, value}
+}
+func MakeAgentInvocationResultAgentMethod(value AgentInvocationOutputParameters) AgentInvocationResult {
+	return AgentInvocationResult{AgentInvocationResultAgentMethod, value}
+}
+func MakeAgentInvocationResultManualUpdate() AgentInvocationResult {
+	return AgentInvocationResult{AgentInvocationResultManualUpdate, nil}
+}
+func MakeAgentInvocationResultLoadSnapshot(value FallibleResultParameters) AgentInvocationResult {
+	return AgentInvocationResult{AgentInvocationResultLoadSnapshot, value}
+}
+func MakeAgentInvocationResultSaveSnapshot(value SaveSnapshotResultParameters) AgentInvocationResult {
+	return AgentInvocationResult{AgentInvocationResultSaveSnapshot, value}
+}
+func MakeAgentInvocationResultProcessOplogEntries(value FallibleResultParameters) AgentInvocationResult {
+	return AgentInvocationResult{AgentInvocationResultProcessOplogEntries, value}
+}
+
+type AgentInvocationFinishedParameters struct {
+	Timestamp         wasi_clocks_0_3_0_system_clock.Instant
+	Result            AgentInvocationResult
+	MethodName        witTypes.Option[string]
+	ConsumedFuel      int64
+	ComponentRevision uint64
+}
+
+type PendingAgentInvocationParameters struct {
+	Timestamp  wasi_clocks_0_3_0_system_clock.Instant
+	Invocation AgentInvocation
+}
+
+type SnapshotParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	Data      SnapshotData
+}
+
+type OplogProcessorCheckpointParameters struct {
+	Timestamp      wasi_clocks_0_3_0_system_clock.Instant
+	Plugin         PluginInstallationDescription
+	TargetAgentId  golem_core_types.AgentId
+	ConfirmedUpTo  uint64
+	SendingUpTo    uint64
+	LastBatchStart uint64
+}
+
+type Timestamp struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+}
+
+type OplogExternalPayload struct {
+	PayloadId golem_core_types.Uuid
+	Md5Hash   []uint8
+}
+
+const (
+	OplogPayloadInline   uint8 = 0
+	OplogPayloadExternal uint8 = 1
+)
+
+// Opaque oplog payload, which can either be serialized inline or stored externally
+type OplogPayload struct {
+	tag   uint8
+	value any
+}
+
+func (self OplogPayload) Tag() uint8 {
+	return self.tag
+}
+
+func (self OplogPayload) Inline() []uint8 {
+	if self.tag != OplogPayloadInline {
+		panic("tag mismatch")
+	}
+	return self.value.([]uint8)
+}
+func (self OplogPayload) External() OplogExternalPayload {
+	if self.tag != OplogPayloadExternal {
+		panic("tag mismatch")
+	}
+	return self.value.(OplogExternalPayload)
+}
+
+func MakeOplogPayloadInline(value []uint8) OplogPayload {
+	return OplogPayload{OplogPayloadInline, value}
+}
+func MakeOplogPayloadExternal(value OplogExternalPayload) OplogPayload {
+	return OplogPayload{OplogPayloadExternal, value}
+}
+
+type AgentTerminatedByQuotaError struct {
+	EnvironmentId golem_api_host.EnvironmentId
+	ResourceName  string
+}
+
+type EphemeralSleepTooLong struct {
+	RequestedNanos uint64
+	MaxNanos       uint64
+}
+
+type EphemeralFuelExhausted struct {
+	OverdraftLimit uint64
+}
+
+type EphemeralCannotSuspend struct {
+	Reason string
+}
+
+type ReadOnlyViolation struct {
+	Method       string
+	HostFunction string
+}
+
+const (
+	WorkerErrorUnknown                             uint8 = 0
+	WorkerErrorInvalidRequest                      uint8 = 1
+	WorkerErrorStackOverflow                       uint8 = 2
+	WorkerErrorOutOfMemory                         uint8 = 3
+	WorkerErrorExceededMemoryLimit                 uint8 = 4
+	WorkerErrorInternalError                       uint8 = 5
+	WorkerErrorDeterministicTrap                   uint8 = 6
+	WorkerErrorTransientError                      uint8 = 7
+	WorkerErrorPermanentError                      uint8 = 8
+	WorkerErrorExceededTableLimit                  uint8 = 9
+	WorkerErrorExceededHttpCallLimit               uint8 = 10
+	WorkerErrorExceededRpcCallLimit                uint8 = 11
+	WorkerErrorNodeOutOfFilesystemStorage          uint8 = 12
+	WorkerErrorAgentExceededFilesystemStorageLimit uint8 = 13
+	WorkerErrorAgentTerminatedByQuota              uint8 = 14
+	WorkerErrorEphemeralSleepTooLong               uint8 = 15
+	WorkerErrorEphemeralFuelExhausted              uint8 = 16
+	WorkerErrorEphemeralCannotSuspend              uint8 = 17
+	WorkerErrorReadOnlyViolation                   uint8 = 18
+)
+
+// Describes the error that occurred in the agent
+type WorkerError struct {
+	tag   uint8
+	value any
+}
+
+func (self WorkerError) Tag() uint8 {
+	return self.tag
+}
+
+func (self WorkerError) Unknown() string {
+	if self.tag != WorkerErrorUnknown {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self WorkerError) InvalidRequest() string {
+	if self.tag != WorkerErrorInvalidRequest {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self WorkerError) InternalError() string {
+	if self.tag != WorkerErrorInternalError {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self WorkerError) DeterministicTrap() string {
+	if self.tag != WorkerErrorDeterministicTrap {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self WorkerError) TransientError() string {
+	if self.tag != WorkerErrorTransientError {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self WorkerError) PermanentError() string {
+	if self.tag != WorkerErrorPermanentError {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self WorkerError) AgentTerminatedByQuota() AgentTerminatedByQuotaError {
+	if self.tag != WorkerErrorAgentTerminatedByQuota {
+		panic("tag mismatch")
+	}
+	return self.value.(AgentTerminatedByQuotaError)
+}
+func (self WorkerError) EphemeralSleepTooLong() EphemeralSleepTooLong {
+	if self.tag != WorkerErrorEphemeralSleepTooLong {
+		panic("tag mismatch")
+	}
+	return self.value.(EphemeralSleepTooLong)
+}
+func (self WorkerError) EphemeralFuelExhausted() EphemeralFuelExhausted {
+	if self.tag != WorkerErrorEphemeralFuelExhausted {
+		panic("tag mismatch")
+	}
+	return self.value.(EphemeralFuelExhausted)
+}
+func (self WorkerError) EphemeralCannotSuspend() EphemeralCannotSuspend {
+	if self.tag != WorkerErrorEphemeralCannotSuspend {
+		panic("tag mismatch")
+	}
+	return self.value.(EphemeralCannotSuspend)
+}
+func (self WorkerError) ReadOnlyViolation() ReadOnlyViolation {
+	if self.tag != WorkerErrorReadOnlyViolation {
+		panic("tag mismatch")
+	}
+	return self.value.(ReadOnlyViolation)
+}
+
+func MakeWorkerErrorUnknown(value string) WorkerError {
+	return WorkerError{WorkerErrorUnknown, value}
+}
+func MakeWorkerErrorInvalidRequest(value string) WorkerError {
+	return WorkerError{WorkerErrorInvalidRequest, value}
+}
+func MakeWorkerErrorStackOverflow() WorkerError {
+	return WorkerError{WorkerErrorStackOverflow, nil}
+}
+func MakeWorkerErrorOutOfMemory() WorkerError {
+	return WorkerError{WorkerErrorOutOfMemory, nil}
+}
+func MakeWorkerErrorExceededMemoryLimit() WorkerError {
+	return WorkerError{WorkerErrorExceededMemoryLimit, nil}
+}
+func MakeWorkerErrorInternalError(value string) WorkerError {
+	return WorkerError{WorkerErrorInternalError, value}
+}
+func MakeWorkerErrorDeterministicTrap(value string) WorkerError {
+	return WorkerError{WorkerErrorDeterministicTrap, value}
+}
+func MakeWorkerErrorTransientError(value string) WorkerError {
+	return WorkerError{WorkerErrorTransientError, value}
+}
+func MakeWorkerErrorPermanentError(value string) WorkerError {
+	return WorkerError{WorkerErrorPermanentError, value}
+}
+func MakeWorkerErrorExceededTableLimit() WorkerError {
+	return WorkerError{WorkerErrorExceededTableLimit, nil}
+}
+func MakeWorkerErrorExceededHttpCallLimit() WorkerError {
+	return WorkerError{WorkerErrorExceededHttpCallLimit, nil}
+}
+func MakeWorkerErrorExceededRpcCallLimit() WorkerError {
+	return WorkerError{WorkerErrorExceededRpcCallLimit, nil}
+}
+func MakeWorkerErrorNodeOutOfFilesystemStorage() WorkerError {
+	return WorkerError{WorkerErrorNodeOutOfFilesystemStorage, nil}
+}
+func MakeWorkerErrorAgentExceededFilesystemStorageLimit() WorkerError {
+	return WorkerError{WorkerErrorAgentExceededFilesystemStorageLimit, nil}
+}
+func MakeWorkerErrorAgentTerminatedByQuota(value AgentTerminatedByQuotaError) WorkerError {
+	return WorkerError{WorkerErrorAgentTerminatedByQuota, value}
+}
+func MakeWorkerErrorEphemeralSleepTooLong(value EphemeralSleepTooLong) WorkerError {
+	return WorkerError{WorkerErrorEphemeralSleepTooLong, value}
+}
+func MakeWorkerErrorEphemeralFuelExhausted(value EphemeralFuelExhausted) WorkerError {
+	return WorkerError{WorkerErrorEphemeralFuelExhausted, value}
+}
+func MakeWorkerErrorEphemeralCannotSuspend(value EphemeralCannotSuspend) WorkerError {
+	return WorkerError{WorkerErrorEphemeralCannotSuspend, value}
+}
+func MakeWorkerErrorReadOnlyViolation(value ReadOnlyViolation) WorkerError {
+	return WorkerError{WorkerErrorReadOnlyViolation, value}
+}
+
+type RawCreateParameters struct {
+	Timestamp                    wasi_clocks_0_3_0_system_clock.Instant
+	AgentId                      golem_core_types.AgentId
+	AgentMode                    AgentMode
+	ComponentRevision            uint64
+	Env                          []witTypes.Tuple2[string, string]
+	EnvironmentId                golem_api_host.EnvironmentId
+	CreatedBy                    golem_core_types.AccountId
+	Parent                       witTypes.Option[golem_core_types.AgentId]
+	ComponentSize                uint64
+	InitialTotalLinearMemorySize uint64
+	InitialActivePlugins         []EnvironmentPluginGrantId
+	LocalAgentConfig             []RawLocalAgentConfigEntry
+	OriginalPhantomId            witTypes.Option[golem_core_types.Uuid]
+	InstanceId                   golem_core_types.Uuid
+}
+
+type RawStartParameters struct {
+	Timestamp           wasi_clocks_0_3_0_system_clock.Instant
+	ParentStartIndex    witTypes.Option[uint64]
+	FunctionName        string
+	Request             witTypes.Option[OplogPayload]
+	DurableFunctionType WrappedFunctionType
+}
+
+type RawEndParameters struct {
+	Timestamp    wasi_clocks_0_3_0_system_clock.Instant
+	StartIndex   uint64
+	Response     witTypes.Option[OplogPayload]
+	ForcedCommit bool
+}
+
+type RawCancelledParameters struct {
+	Timestamp  wasi_clocks_0_3_0_system_clock.Instant
+	StartIndex uint64
+	Partial    witTypes.Option[OplogPayload]
+}
+
+type RawCompletionDiscardedParameters struct {
+	Timestamp  wasi_clocks_0_3_0_system_clock.Instant
+	StartIndex uint64
+}
+
+// Parameters for a host-stream-frame oplog entry, with the frame payload in raw
+// (possibly externally stored) form.
+type RawHostStreamFrameParameters struct {
+	Timestamp        wasi_clocks_0_3_0_system_clock.Instant
+	ParentStartIndex uint64
+	Kind             HostStreamKind
+	Payload          OplogPayload
+}
+
+type RawAgentInvocationStartedParameters struct {
+	Timestamp         wasi_clocks_0_3_0_system_clock.Instant
+	IdempotencyKey    string
+	Payload           OplogPayload
+	TraceId           string
+	TraceStates       []string
+	InvocationContext []SpanData
+}
+
+type RawAgentInvocationFinishedParameters struct {
+	Timestamp         wasi_clocks_0_3_0_system_clock.Instant
+	Result            OplogPayload
+	MethodName        witTypes.Option[string]
+	ConsumedFuel      int64
+	ComponentRevision uint64
+}
+
+type RawErrorParameters struct {
+	Timestamp          wasi_clocks_0_3_0_system_clock.Instant
+	Error              WorkerError
+	RetryFrom          uint64
+	InsideAtomicRegion bool
+	// Persistent retry policy state, if a semantic retry policy is active.
+	RetryPolicyState witTypes.Option[RetryPolicyState]
+}
+
+type RawPendingAgentInvocationParameters struct {
+	Timestamp         wasi_clocks_0_3_0_system_clock.Instant
+	IdempotencyKey    string
+	Payload           OplogPayload
+	TraceId           string
+	TraceStates       []string
+	InvocationContext []SpanData
+}
+
+type RawSnapshotBasedUpdate struct {
+	TargetRevision uint64
+	Payload        OplogPayload
+	MimeType       string
+}
+
+const (
+	// Automatic update by replaying the oplog on the new version
+	RawUpdateDescriptionAutomatic uint8 = 0
+	// Custom update by loading a given snapshot on the new version
+	RawUpdateDescriptionSnapshotBased uint8 = 1
+)
+
+// Raw update description used in oplog entries
+type RawUpdateDescription struct {
+	tag   uint8
+	value any
+}
+
+func (self RawUpdateDescription) Tag() uint8 {
+	return self.tag
+}
+
+func (self RawUpdateDescription) Automatic() uint64 {
+	if self.tag != RawUpdateDescriptionAutomatic {
+		panic("tag mismatch")
+	}
+	return self.value.(uint64)
+}
+func (self RawUpdateDescription) SnapshotBased() RawSnapshotBasedUpdate {
+	if self.tag != RawUpdateDescriptionSnapshotBased {
+		panic("tag mismatch")
+	}
+	return self.value.(RawSnapshotBasedUpdate)
+}
+
+func MakeRawUpdateDescriptionAutomatic(value uint64) RawUpdateDescription {
+	return RawUpdateDescription{RawUpdateDescriptionAutomatic, value}
+}
+func MakeRawUpdateDescriptionSnapshotBased(value RawSnapshotBasedUpdate) RawUpdateDescription {
+	return RawUpdateDescription{RawUpdateDescriptionSnapshotBased, value}
+}
+
+type RawPendingUpdateParameters struct {
+	Timestamp   wasi_clocks_0_3_0_system_clock.Instant
+	Description RawUpdateDescription
+}
+
+type RawSuccessfulUpdateParameters struct {
+	Timestamp        wasi_clocks_0_3_0_system_clock.Instant
+	TargetRevision   uint64
+	NewComponentSize uint64
+	NewActivePlugins []EnvironmentPluginGrantId
+}
+
+type ResourceTypeId struct {
+	Name  string
+	Owner string
+}
+
+type RawCreateResourceParameters struct {
+	Timestamp      wasi_clocks_0_3_0_system_clock.Instant
+	Id             uint64
+	ResourceTypeId ResourceTypeId
+}
+
+type RawDropResourceParameters struct {
+	Timestamp      wasi_clocks_0_3_0_system_clock.Instant
+	Id             uint64
+	ResourceTypeId ResourceTypeId
+}
+
+type RawActivatePluginParameters struct {
+	Timestamp     wasi_clocks_0_3_0_system_clock.Instant
+	PluginGrantId EnvironmentPluginGrantId
+}
+
+type RawDeactivatePluginParameters struct {
+	Timestamp     wasi_clocks_0_3_0_system_clock.Instant
+	PluginGrantId EnvironmentPluginGrantId
+}
+
+type RawBeginRemoteTransactionParameters struct {
+	Timestamp          wasi_clocks_0_3_0_system_clock.Instant
+	TransactionId      string
+	OriginalBeginIndex witTypes.Option[uint64]
+}
+
+type RawSnapshotParameters struct {
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	Data      OplogPayload
+	MimeType  string
+}
+
+type RawOplogProcessorCheckpointParameters struct {
+	Timestamp      wasi_clocks_0_3_0_system_clock.Instant
+	PluginGrantId  EnvironmentPluginGrantId
+	TargetAgentId  golem_core_types.AgentId
+	ConfirmedUpTo  uint64
+	SendingUpTo    uint64
+	LastBatchStart uint64
+}
+
+const (
+	// The initial agent oplog entry
+	OplogEntryCreate uint8 = 0
+	// Marks the start of a durable host call (or scope such as a batched-write).
+	OplogEntryStart uint8 = 1
+	// Marks the successful completion of a durable host call (or scope) started by a matching `Start`.
+	OplogEntryEnd uint8 = 2
+	// Marks that a durable host call started by a matching `Start` was cancelled
+	// (e.g. dropped from a `select!`) before producing a final response.
+	OplogEntryCancelled uint8 = 3
+	// The agent has been invoked
+	OplogEntryAgentInvocationStarted uint8 = 4
+	// The agent has completed an invocation
+	OplogEntryAgentInvocationFinished uint8 = 5
+	// Agent suspended
+	OplogEntrySuspend uint8 = 6
+	// Agent failed
+	OplogEntryError uint8 = 7
+	// Marker entry added when get-oplog-index is called from the agent, to make the jumping behavior
+	// more predictable.
+	OplogEntryNoOp uint8 = 8
+	// The agent needs to recover up to the given target oplog index and continue running from
+	// the source oplog index from there
+	// `jump` is an oplog region representing that from the end of that region we want to go back to the start and
+	// ignore all recorded operations in between.
+	OplogEntryJump uint8 = 9
+	// Indicates that the agent has been interrupted at this point.
+	// Only used to recompute the agent's (cached) status, has no effect on execution.
+	OplogEntryInterrupted uint8 = 10
+	// Indicates that the agent has been exited using WASI's exit function.
+	OplogEntryExited uint8 = 11
+	// Begins an atomic region. All oplog entries after `BeginAtomicRegion` are to be ignored during
+	// recovery except if there is a corresponding `EndAtomicRegion` entry.
+	OplogEntryBeginAtomicRegion uint8 = 12
+	// Ends an atomic region. All oplog entries between the corresponding `BeginAtomicRegion` and this
+	// entry are to be considered during recovery, and the begin/end markers can be removed during oplog
+	// compaction.
+	OplogEntryEndAtomicRegion uint8 = 13
+	// An invocation request arrived while the agent was busy
+	OplogEntryPendingAgentInvocation uint8 = 14
+	// An update request arrived and will be applied as soon the agent restarts
+	OplogEntryPendingUpdate uint8 = 15
+	// An update was successfully applied
+	OplogEntrySuccessfulUpdate uint8 = 16
+	// An update failed to be applied
+	OplogEntryFailedUpdate uint8 = 17
+	// Increased total linear memory size
+	OplogEntryGrowMemory uint8 = 18
+	// Updated filesystem usage by a signed delta
+	OplogEntryFilesystemStorageUsageUpdate uint8 = 19
+	// Created a resource instance
+	OplogEntryCreateResource uint8 = 20
+	// Dropped a resource instance
+	OplogEntryDropResource uint8 = 21
+	// The agent emitted a log message
+	OplogEntryLog uint8 = 22
+	// The agent has been restarted, forgetting all its history
+	OplogEntryRestart uint8 = 23
+	// Activates a plugin
+	OplogEntryActivatePlugin uint8 = 24
+	// Deactivates a plugin
+	OplogEntryDeactivatePlugin uint8 = 25
+	// Revert an agent to a previous state
+	OplogEntryRevert uint8 = 26
+	// Cancel a pending invocation
+	OplogEntryCancelPendingInvocation uint8 = 27
+	// Start a new span in the invocation context
+	OplogEntryStartSpan uint8 = 28
+	// Finish an open span in the invocation context
+	OplogEntryFinishSpan uint8 = 29
+	// Set an attribute on an open span in the invocation context
+	OplogEntrySetSpanAttribute uint8 = 30
+	// Change the current persistence level
+	OplogEntryChangePersistenceLevel uint8 = 31
+	// Begins a transaction operation
+	OplogEntryBeginRemoteTransaction uint8 = 32
+	// Pre-Commit of the transaction, indicating that the transaction will be committed
+	OplogEntryPreCommitRemoteTransaction uint8 = 33
+	// Pre-Rollback of the transaction, indicating that the transaction will be rolled back
+	OplogEntryPreRollbackRemoteTransaction uint8 = 34
+	// Committed transaction operation, indicating that the transaction was committed
+	OplogEntryCommittedRemoteTransaction uint8 = 35
+	// Rolled back transaction operation, indicating that the transaction was rolled back
+	OplogEntryRolledBackRemoteTransaction uint8 = 36
+	// A snapshot of the agent's state
+	OplogEntrySnapshot uint8 = 37
+	// Checkpoint for oplog processor plugin delivery tracking
+	OplogEntryOplogProcessorCheckpoint uint8 = 38
+	// Sets or overwrites a named retry policy
+	OplogEntrySetRetryPolicy uint8 = 39
+	// Removes a named retry policy by name
+	OplogEntryRemoveRetryPolicy uint8 = 40
+	// Durable queue entry for pending permission-card work
+	OplogEntryCardEventQueued uint8 = 41
+	// Records successful installation of a permission card into the agent wallet
+	OplogEntryCardInstalled uint8 = 42
+	// Records failed installation of a permission card into the agent wallet
+	OplogEntryCardInstallFailed uint8 = 43
+	// Records that a permission card used by the agent has been revoked
+	OplogEntryCardRevoked uint8 = 44
+	// Records that a permission card used by the agent has expired
+	OplogEntryCardExpired uint8 = 45
+	// A durably recorded frame of a host-owned stream (e.g. an outgoing HTTP request body),
+	// attached to the durable host call identified by its start entry's index
+	OplogEntryHostStreamFrame uint8 = 46
+	// The successful completion of the durable host call started by the matching `start`
+	// was persisted, but its response was never delivered to the agent (the agent dropped
+	// the completion future after the `end` was recorded)
+	OplogEntryCompletionDiscarded uint8 = 47
+)
+
+type OplogEntry struct {
+	tag   uint8
+	value any
+}
+
+func (self OplogEntry) Tag() uint8 {
+	return self.tag
+}
+
+func (self OplogEntry) Create() RawCreateParameters {
+	if self.tag != OplogEntryCreate {
+		panic("tag mismatch")
+	}
+	return self.value.(RawCreateParameters)
+}
+func (self OplogEntry) Start() RawStartParameters {
+	if self.tag != OplogEntryStart {
+		panic("tag mismatch")
+	}
+	return self.value.(RawStartParameters)
+}
+func (self OplogEntry) End() RawEndParameters {
+	if self.tag != OplogEntryEnd {
+		panic("tag mismatch")
+	}
+	return self.value.(RawEndParameters)
+}
+func (self OplogEntry) Cancelled() RawCancelledParameters {
+	if self.tag != OplogEntryCancelled {
+		panic("tag mismatch")
+	}
+	return self.value.(RawCancelledParameters)
+}
+func (self OplogEntry) AgentInvocationStarted() RawAgentInvocationStartedParameters {
+	if self.tag != OplogEntryAgentInvocationStarted {
+		panic("tag mismatch")
+	}
+	return self.value.(RawAgentInvocationStartedParameters)
+}
+func (self OplogEntry) AgentInvocationFinished() RawAgentInvocationFinishedParameters {
+	if self.tag != OplogEntryAgentInvocationFinished {
+		panic("tag mismatch")
+	}
+	return self.value.(RawAgentInvocationFinishedParameters)
+}
+func (self OplogEntry) Suspend() Timestamp {
+	if self.tag != OplogEntrySuspend {
+		panic("tag mismatch")
+	}
+	return self.value.(Timestamp)
+}
+func (self OplogEntry) Error() RawErrorParameters {
+	if self.tag != OplogEntryError {
+		panic("tag mismatch")
+	}
+	return self.value.(RawErrorParameters)
+}
+func (self OplogEntry) NoOp() Timestamp {
+	if self.tag != OplogEntryNoOp {
+		panic("tag mismatch")
+	}
+	return self.value.(Timestamp)
+}
+func (self OplogEntry) Jump() JumpParameters {
+	if self.tag != OplogEntryJump {
+		panic("tag mismatch")
+	}
+	return self.value.(JumpParameters)
+}
+func (self OplogEntry) Interrupted() Timestamp {
+	if self.tag != OplogEntryInterrupted {
+		panic("tag mismatch")
+	}
+	return self.value.(Timestamp)
+}
+func (self OplogEntry) Exited() Timestamp {
+	if self.tag != OplogEntryExited {
+		panic("tag mismatch")
+	}
+	return self.value.(Timestamp)
+}
+func (self OplogEntry) BeginAtomicRegion() Timestamp {
+	if self.tag != OplogEntryBeginAtomicRegion {
+		panic("tag mismatch")
+	}
+	return self.value.(Timestamp)
+}
+func (self OplogEntry) EndAtomicRegion() EndAtomicRegionParameters {
+	if self.tag != OplogEntryEndAtomicRegion {
+		panic("tag mismatch")
+	}
+	return self.value.(EndAtomicRegionParameters)
+}
+func (self OplogEntry) PendingAgentInvocation() RawPendingAgentInvocationParameters {
+	if self.tag != OplogEntryPendingAgentInvocation {
+		panic("tag mismatch")
+	}
+	return self.value.(RawPendingAgentInvocationParameters)
+}
+func (self OplogEntry) PendingUpdate() RawPendingUpdateParameters {
+	if self.tag != OplogEntryPendingUpdate {
+		panic("tag mismatch")
+	}
+	return self.value.(RawPendingUpdateParameters)
+}
+func (self OplogEntry) SuccessfulUpdate() RawSuccessfulUpdateParameters {
+	if self.tag != OplogEntrySuccessfulUpdate {
+		panic("tag mismatch")
+	}
+	return self.value.(RawSuccessfulUpdateParameters)
+}
+func (self OplogEntry) FailedUpdate() FailedUpdateParameters {
+	if self.tag != OplogEntryFailedUpdate {
+		panic("tag mismatch")
+	}
+	return self.value.(FailedUpdateParameters)
+}
+func (self OplogEntry) GrowMemory() GrowMemoryParameters {
+	if self.tag != OplogEntryGrowMemory {
+		panic("tag mismatch")
+	}
+	return self.value.(GrowMemoryParameters)
+}
+func (self OplogEntry) FilesystemStorageUsageUpdate() FilesystemStorageUsageUpdateParameters {
+	if self.tag != OplogEntryFilesystemStorageUsageUpdate {
+		panic("tag mismatch")
+	}
+	return self.value.(FilesystemStorageUsageUpdateParameters)
+}
+func (self OplogEntry) CreateResource() RawCreateResourceParameters {
+	if self.tag != OplogEntryCreateResource {
+		panic("tag mismatch")
+	}
+	return self.value.(RawCreateResourceParameters)
+}
+func (self OplogEntry) DropResource() RawDropResourceParameters {
+	if self.tag != OplogEntryDropResource {
+		panic("tag mismatch")
+	}
+	return self.value.(RawDropResourceParameters)
+}
+func (self OplogEntry) Log() LogParameters {
+	if self.tag != OplogEntryLog {
+		panic("tag mismatch")
+	}
+	return self.value.(LogParameters)
+}
+func (self OplogEntry) Restart() Timestamp {
+	if self.tag != OplogEntryRestart {
+		panic("tag mismatch")
+	}
+	return self.value.(Timestamp)
+}
+func (self OplogEntry) ActivatePlugin() RawActivatePluginParameters {
+	if self.tag != OplogEntryActivatePlugin {
+		panic("tag mismatch")
+	}
+	return self.value.(RawActivatePluginParameters)
+}
+func (self OplogEntry) DeactivatePlugin() RawDeactivatePluginParameters {
+	if self.tag != OplogEntryDeactivatePlugin {
+		panic("tag mismatch")
+	}
+	return self.value.(RawDeactivatePluginParameters)
+}
+func (self OplogEntry) Revert() RevertParameters {
+	if self.tag != OplogEntryRevert {
+		panic("tag mismatch")
+	}
+	return self.value.(RevertParameters)
+}
+func (self OplogEntry) CancelPendingInvocation() CancelPendingInvocationParameters {
+	if self.tag != OplogEntryCancelPendingInvocation {
+		panic("tag mismatch")
+	}
+	return self.value.(CancelPendingInvocationParameters)
+}
+func (self OplogEntry) StartSpan() StartSpanParameters {
+	if self.tag != OplogEntryStartSpan {
+		panic("tag mismatch")
+	}
+	return self.value.(StartSpanParameters)
+}
+func (self OplogEntry) FinishSpan() FinishSpanParameters {
+	if self.tag != OplogEntryFinishSpan {
+		panic("tag mismatch")
+	}
+	return self.value.(FinishSpanParameters)
+}
+func (self OplogEntry) SetSpanAttribute() SetSpanAttributeParameters {
+	if self.tag != OplogEntrySetSpanAttribute {
+		panic("tag mismatch")
+	}
+	return self.value.(SetSpanAttributeParameters)
+}
+func (self OplogEntry) ChangePersistenceLevel() ChangePersistenceLevelParameters {
+	if self.tag != OplogEntryChangePersistenceLevel {
+		panic("tag mismatch")
+	}
+	return self.value.(ChangePersistenceLevelParameters)
+}
+func (self OplogEntry) BeginRemoteTransaction() RawBeginRemoteTransactionParameters {
+	if self.tag != OplogEntryBeginRemoteTransaction {
+		panic("tag mismatch")
+	}
+	return self.value.(RawBeginRemoteTransactionParameters)
+}
+func (self OplogEntry) PreCommitRemoteTransaction() RemoteTransactionParameters {
+	if self.tag != OplogEntryPreCommitRemoteTransaction {
+		panic("tag mismatch")
+	}
+	return self.value.(RemoteTransactionParameters)
+}
+func (self OplogEntry) PreRollbackRemoteTransaction() RemoteTransactionParameters {
+	if self.tag != OplogEntryPreRollbackRemoteTransaction {
+		panic("tag mismatch")
+	}
+	return self.value.(RemoteTransactionParameters)
+}
+func (self OplogEntry) CommittedRemoteTransaction() RemoteTransactionParameters {
+	if self.tag != OplogEntryCommittedRemoteTransaction {
+		panic("tag mismatch")
+	}
+	return self.value.(RemoteTransactionParameters)
+}
+func (self OplogEntry) RolledBackRemoteTransaction() RemoteTransactionParameters {
+	if self.tag != OplogEntryRolledBackRemoteTransaction {
+		panic("tag mismatch")
+	}
+	return self.value.(RemoteTransactionParameters)
+}
+func (self OplogEntry) Snapshot() RawSnapshotParameters {
+	if self.tag != OplogEntrySnapshot {
+		panic("tag mismatch")
+	}
+	return self.value.(RawSnapshotParameters)
+}
+func (self OplogEntry) OplogProcessorCheckpoint() RawOplogProcessorCheckpointParameters {
+	if self.tag != OplogEntryOplogProcessorCheckpoint {
+		panic("tag mismatch")
+	}
+	return self.value.(RawOplogProcessorCheckpointParameters)
+}
+func (self OplogEntry) SetRetryPolicy() SetRetryPolicyParameters {
+	if self.tag != OplogEntrySetRetryPolicy {
+		panic("tag mismatch")
+	}
+	return self.value.(SetRetryPolicyParameters)
+}
+func (self OplogEntry) RemoveRetryPolicy() RemoveRetryPolicyParameters {
+	if self.tag != OplogEntryRemoveRetryPolicy {
+		panic("tag mismatch")
+	}
+	return self.value.(RemoveRetryPolicyParameters)
+}
+func (self OplogEntry) CardEventQueued() CardEventQueuedParameters {
+	if self.tag != OplogEntryCardEventQueued {
+		panic("tag mismatch")
+	}
+	return self.value.(CardEventQueuedParameters)
+}
+func (self OplogEntry) CardInstalled() RawCardInstalledParameters {
+	if self.tag != OplogEntryCardInstalled {
+		panic("tag mismatch")
+	}
+	return self.value.(RawCardInstalledParameters)
+}
+func (self OplogEntry) CardInstallFailed() CardInstallFailedParameters {
+	if self.tag != OplogEntryCardInstallFailed {
+		panic("tag mismatch")
+	}
+	return self.value.(CardInstallFailedParameters)
+}
+func (self OplogEntry) CardRevoked() CardRevokedParameters {
+	if self.tag != OplogEntryCardRevoked {
+		panic("tag mismatch")
+	}
+	return self.value.(CardRevokedParameters)
+}
+func (self OplogEntry) CardExpired() CardExpiredParameters {
+	if self.tag != OplogEntryCardExpired {
+		panic("tag mismatch")
+	}
+	return self.value.(CardExpiredParameters)
+}
+func (self OplogEntry) HostStreamFrame() RawHostStreamFrameParameters {
+	if self.tag != OplogEntryHostStreamFrame {
+		panic("tag mismatch")
+	}
+	return self.value.(RawHostStreamFrameParameters)
+}
+func (self OplogEntry) CompletionDiscarded() RawCompletionDiscardedParameters {
+	if self.tag != OplogEntryCompletionDiscarded {
+		panic("tag mismatch")
+	}
+	return self.value.(RawCompletionDiscardedParameters)
+}
+
+func MakeOplogEntryCreate(value RawCreateParameters) OplogEntry {
+	return OplogEntry{OplogEntryCreate, value}
+}
+func MakeOplogEntryStart(value RawStartParameters) OplogEntry {
+	return OplogEntry{OplogEntryStart, value}
+}
+func MakeOplogEntryEnd(value RawEndParameters) OplogEntry {
+	return OplogEntry{OplogEntryEnd, value}
+}
+func MakeOplogEntryCancelled(value RawCancelledParameters) OplogEntry {
+	return OplogEntry{OplogEntryCancelled, value}
+}
+func MakeOplogEntryAgentInvocationStarted(value RawAgentInvocationStartedParameters) OplogEntry {
+	return OplogEntry{OplogEntryAgentInvocationStarted, value}
+}
+func MakeOplogEntryAgentInvocationFinished(value RawAgentInvocationFinishedParameters) OplogEntry {
+	return OplogEntry{OplogEntryAgentInvocationFinished, value}
+}
+func MakeOplogEntrySuspend(value Timestamp) OplogEntry {
+	return OplogEntry{OplogEntrySuspend, value}
+}
+func MakeOplogEntryError(value RawErrorParameters) OplogEntry {
+	return OplogEntry{OplogEntryError, value}
+}
+func MakeOplogEntryNoOp(value Timestamp) OplogEntry {
+	return OplogEntry{OplogEntryNoOp, value}
+}
+func MakeOplogEntryJump(value JumpParameters) OplogEntry {
+	return OplogEntry{OplogEntryJump, value}
+}
+func MakeOplogEntryInterrupted(value Timestamp) OplogEntry {
+	return OplogEntry{OplogEntryInterrupted, value}
+}
+func MakeOplogEntryExited(value Timestamp) OplogEntry {
+	return OplogEntry{OplogEntryExited, value}
+}
+func MakeOplogEntryBeginAtomicRegion(value Timestamp) OplogEntry {
+	return OplogEntry{OplogEntryBeginAtomicRegion, value}
+}
+func MakeOplogEntryEndAtomicRegion(value EndAtomicRegionParameters) OplogEntry {
+	return OplogEntry{OplogEntryEndAtomicRegion, value}
+}
+func MakeOplogEntryPendingAgentInvocation(value RawPendingAgentInvocationParameters) OplogEntry {
+	return OplogEntry{OplogEntryPendingAgentInvocation, value}
+}
+func MakeOplogEntryPendingUpdate(value RawPendingUpdateParameters) OplogEntry {
+	return OplogEntry{OplogEntryPendingUpdate, value}
+}
+func MakeOplogEntrySuccessfulUpdate(value RawSuccessfulUpdateParameters) OplogEntry {
+	return OplogEntry{OplogEntrySuccessfulUpdate, value}
+}
+func MakeOplogEntryFailedUpdate(value FailedUpdateParameters) OplogEntry {
+	return OplogEntry{OplogEntryFailedUpdate, value}
+}
+func MakeOplogEntryGrowMemory(value GrowMemoryParameters) OplogEntry {
+	return OplogEntry{OplogEntryGrowMemory, value}
+}
+func MakeOplogEntryFilesystemStorageUsageUpdate(value FilesystemStorageUsageUpdateParameters) OplogEntry {
+	return OplogEntry{OplogEntryFilesystemStorageUsageUpdate, value}
+}
+func MakeOplogEntryCreateResource(value RawCreateResourceParameters) OplogEntry {
+	return OplogEntry{OplogEntryCreateResource, value}
+}
+func MakeOplogEntryDropResource(value RawDropResourceParameters) OplogEntry {
+	return OplogEntry{OplogEntryDropResource, value}
+}
+func MakeOplogEntryLog(value LogParameters) OplogEntry {
+	return OplogEntry{OplogEntryLog, value}
+}
+func MakeOplogEntryRestart(value Timestamp) OplogEntry {
+	return OplogEntry{OplogEntryRestart, value}
+}
+func MakeOplogEntryActivatePlugin(value RawActivatePluginParameters) OplogEntry {
+	return OplogEntry{OplogEntryActivatePlugin, value}
+}
+func MakeOplogEntryDeactivatePlugin(value RawDeactivatePluginParameters) OplogEntry {
+	return OplogEntry{OplogEntryDeactivatePlugin, value}
+}
+func MakeOplogEntryRevert(value RevertParameters) OplogEntry {
+	return OplogEntry{OplogEntryRevert, value}
+}
+func MakeOplogEntryCancelPendingInvocation(value CancelPendingInvocationParameters) OplogEntry {
+	return OplogEntry{OplogEntryCancelPendingInvocation, value}
+}
+func MakeOplogEntryStartSpan(value StartSpanParameters) OplogEntry {
+	return OplogEntry{OplogEntryStartSpan, value}
+}
+func MakeOplogEntryFinishSpan(value FinishSpanParameters) OplogEntry {
+	return OplogEntry{OplogEntryFinishSpan, value}
+}
+func MakeOplogEntrySetSpanAttribute(value SetSpanAttributeParameters) OplogEntry {
+	return OplogEntry{OplogEntrySetSpanAttribute, value}
+}
+func MakeOplogEntryChangePersistenceLevel(value ChangePersistenceLevelParameters) OplogEntry {
+	return OplogEntry{OplogEntryChangePersistenceLevel, value}
+}
+func MakeOplogEntryBeginRemoteTransaction(value RawBeginRemoteTransactionParameters) OplogEntry {
+	return OplogEntry{OplogEntryBeginRemoteTransaction, value}
+}
+func MakeOplogEntryPreCommitRemoteTransaction(value RemoteTransactionParameters) OplogEntry {
+	return OplogEntry{OplogEntryPreCommitRemoteTransaction, value}
+}
+func MakeOplogEntryPreRollbackRemoteTransaction(value RemoteTransactionParameters) OplogEntry {
+	return OplogEntry{OplogEntryPreRollbackRemoteTransaction, value}
+}
+func MakeOplogEntryCommittedRemoteTransaction(value RemoteTransactionParameters) OplogEntry {
+	return OplogEntry{OplogEntryCommittedRemoteTransaction, value}
+}
+func MakeOplogEntryRolledBackRemoteTransaction(value RemoteTransactionParameters) OplogEntry {
+	return OplogEntry{OplogEntryRolledBackRemoteTransaction, value}
+}
+func MakeOplogEntrySnapshot(value RawSnapshotParameters) OplogEntry {
+	return OplogEntry{OplogEntrySnapshot, value}
+}
+func MakeOplogEntryOplogProcessorCheckpoint(value RawOplogProcessorCheckpointParameters) OplogEntry {
+	return OplogEntry{OplogEntryOplogProcessorCheckpoint, value}
+}
+func MakeOplogEntrySetRetryPolicy(value SetRetryPolicyParameters) OplogEntry {
+	return OplogEntry{OplogEntrySetRetryPolicy, value}
+}
+func MakeOplogEntryRemoveRetryPolicy(value RemoveRetryPolicyParameters) OplogEntry {
+	return OplogEntry{OplogEntryRemoveRetryPolicy, value}
+}
+func MakeOplogEntryCardEventQueued(value CardEventQueuedParameters) OplogEntry {
+	return OplogEntry{OplogEntryCardEventQueued, value}
+}
+func MakeOplogEntryCardInstalled(value RawCardInstalledParameters) OplogEntry {
+	return OplogEntry{OplogEntryCardInstalled, value}
+}
+func MakeOplogEntryCardInstallFailed(value CardInstallFailedParameters) OplogEntry {
+	return OplogEntry{OplogEntryCardInstallFailed, value}
+}
+func MakeOplogEntryCardRevoked(value CardRevokedParameters) OplogEntry {
+	return OplogEntry{OplogEntryCardRevoked, value}
+}
+func MakeOplogEntryCardExpired(value CardExpiredParameters) OplogEntry {
+	return OplogEntry{OplogEntryCardExpired, value}
+}
+func MakeOplogEntryHostStreamFrame(value RawHostStreamFrameParameters) OplogEntry {
+	return OplogEntry{OplogEntryHostStreamFrame, value}
+}
+func MakeOplogEntryCompletionDiscarded(value RawCompletionDiscardedParameters) OplogEntry {
+	return OplogEntry{OplogEntryCompletionDiscarded, value}
+}
+
+const (
+	// The initial agent oplog entry
+	PublicOplogEntryCreate uint8 = 0
+	// Marks the start of a durable host call (or scope such as a batched-write).
+	PublicOplogEntryStart uint8 = 1
+	// Marks the successful completion of a durable host call (or scope) started by a matching `Start`.
+	PublicOplogEntryEnd uint8 = 2
+	// Marks that a durable host call started by a matching `Start` was cancelled
+	// (e.g. dropped from a `select!`) before producing a final response.
+	PublicOplogEntryCancelled uint8 = 3
+	// The agent has been invoked
+	PublicOplogEntryAgentInvocationStarted uint8 = 4
+	// The agent has completed an invocation
+	PublicOplogEntryAgentInvocationFinished uint8 = 5
+	// Agent suspended
+	PublicOplogEntrySuspend uint8 = 6
+	// Agent failed
+	PublicOplogEntryError uint8 = 7
+	// Marker entry added when get-oplog-index is called from the agent, to make the jumping behavior
+	// more predictable.
+	PublicOplogEntryNoOp uint8 = 8
+	// The agent needs to recover up to the given target oplog index and continue running from
+	// the source oplog index from there
+	// `jump` is an oplog region representing that from the end of that region we want to go back to the start and
+	// ignore all recorded operations in between.
+	PublicOplogEntryJump uint8 = 9
+	// Indicates that the agent has been interrupted at this point.
+	// Only used to recompute the agent's (cached) status, has no effect on execution.
+	PublicOplogEntryInterrupted uint8 = 10
+	// Indicates that the agent has been exited using WASI's exit function.
+	PublicOplogEntryExited uint8 = 11
+	// Begins an atomic region. All oplog entries after `BeginAtomicRegion` are to be ignored during
+	// recovery except if there is a corresponding `EndAtomicRegion` entry.
+	PublicOplogEntryBeginAtomicRegion uint8 = 12
+	// Ends an atomic region. All oplog entries between the corresponding `BeginAtomicRegion` and this
+	// entry are to be considered during recovery, and the begin/end markers can be removed during oplog
+	// compaction.
+	PublicOplogEntryEndAtomicRegion uint8 = 13
+	// An invocation request arrived while the agent was busy
+	PublicOplogEntryPendingAgentInvocation uint8 = 14
+	// An update request arrived and will be applied as soon the agent restarts
+	PublicOplogEntryPendingUpdate uint8 = 15
+	// An update was successfully applied
+	PublicOplogEntrySuccessfulUpdate uint8 = 16
+	// An update failed to be applied
+	PublicOplogEntryFailedUpdate uint8 = 17
+	// Increased total linear memory size
+	PublicOplogEntryGrowMemory uint8 = 18
+	// Updated filesystem usage by a signed delta
+	PublicOplogEntryFilesystemStorageUsageUpdate uint8 = 19
+	// Created a resource instance
+	PublicOplogEntryCreateResource uint8 = 20
+	// Dropped a resource instance
+	PublicOplogEntryDropResource uint8 = 21
+	// The agent emitted a log message
+	PublicOplogEntryLog uint8 = 22
+	// The agent's has been restarted, forgetting all its history
+	PublicOplogEntryRestart uint8 = 23
+	// Activates a plugin
+	PublicOplogEntryActivatePlugin uint8 = 24
+	// Deactivates a plugin
+	PublicOplogEntryDeactivatePlugin uint8 = 25
+	// Revert an agent to a previous state
+	PublicOplogEntryRevert uint8 = 26
+	// Cancel a pending invocation
+	PublicOplogEntryCancelPendingInvocation uint8 = 27
+	// Start a new span in the invocation context
+	PublicOplogEntryStartSpan uint8 = 28
+	// Finish an open span in the invocation context
+	PublicOplogEntryFinishSpan uint8 = 29
+	// Set an attribute on an open span in the invocation context
+	PublicOplogEntrySetSpanAttribute uint8 = 30
+	// Change the current persistence level
+	PublicOplogEntryChangePersistenceLevel uint8 = 31
+	// Begins a transaction operation
+	PublicOplogEntryBeginRemoteTransaction uint8 = 32
+	// Pre-Commit of the transaction, indicating that the transaction will be committed
+	PublicOplogEntryPreCommitRemoteTransaction uint8 = 33
+	// Pre-Rollback of the transaction, indicating that the transaction will be rolled back
+	PublicOplogEntryPreRollbackRemoteTransaction uint8 = 34
+	// Committed transaction operation, indicating that the transaction was committed
+	PublicOplogEntryCommittedRemoteTransaction uint8 = 35
+	// Rolled back transaction operation, indicating that the transaction was rolled back
+	PublicOplogEntryRolledBackRemoteTransaction uint8 = 36
+	// A snapshot of the worker's state
+	PublicOplogEntrySnapshot uint8 = 37
+	// Checkpoint for oplog processor plugin delivery tracking
+	PublicOplogEntryOplogProcessorCheckpoint uint8 = 38
+	// Sets or overwrites a named retry policy
+	PublicOplogEntrySetRetryPolicy uint8 = 39
+	// Removes a named retry policy by name
+	PublicOplogEntryRemoveRetryPolicy uint8 = 40
+	// Durable queue entry for pending permission-card work
+	PublicOplogEntryCardEventQueued uint8 = 41
+	// Records successful installation of a permission card into the agent wallet
+	PublicOplogEntryCardInstalled uint8 = 42
+	// Records failed installation of a permission card into the agent wallet
+	PublicOplogEntryCardInstallFailed uint8 = 43
+	// Records that a permission card used by the agent has been revoked
+	PublicOplogEntryCardRevoked uint8 = 44
+	// Records that a permission card used by the agent has expired
+	PublicOplogEntryCardExpired uint8 = 45
+	// A durably recorded frame of a host-owned stream (e.g. an outgoing HTTP request body),
+	// attached to the durable host call identified by its start entry's index
+	PublicOplogEntryHostStreamFrame uint8 = 46
+	// The successful completion of the durable host call started by the matching `start`
+	// was persisted, but its response was never delivered to the agent (the agent dropped
+	// the completion future after the `end` was recorded)
+	PublicOplogEntryCompletionDiscarded uint8 = 47
+)
+
+type PublicOplogEntry struct {
+	tag   uint8
+	value any
+}
+
+func (self PublicOplogEntry) Tag() uint8 {
+	return self.tag
+}
+
+func (self PublicOplogEntry) Create() CreateParameters {
+	if self.tag != PublicOplogEntryCreate {
+		panic("tag mismatch")
+	}
+	return self.value.(CreateParameters)
+}
+func (self PublicOplogEntry) Start() StartParameters {
+	if self.tag != PublicOplogEntryStart {
+		panic("tag mismatch")
+	}
+	return self.value.(StartParameters)
+}
+func (self PublicOplogEntry) End() EndParameters {
+	if self.tag != PublicOplogEntryEnd {
+		panic("tag mismatch")
+	}
+	return self.value.(EndParameters)
+}
+func (self PublicOplogEntry) Cancelled() CancelledParameters {
+	if self.tag != PublicOplogEntryCancelled {
+		panic("tag mismatch")
+	}
+	return self.value.(CancelledParameters)
+}
+func (self PublicOplogEntry) AgentInvocationStarted() AgentInvocationStartedParameters {
+	if self.tag != PublicOplogEntryAgentInvocationStarted {
+		panic("tag mismatch")
+	}
+	return self.value.(AgentInvocationStartedParameters)
+}
+func (self PublicOplogEntry) AgentInvocationFinished() AgentInvocationFinishedParameters {
+	if self.tag != PublicOplogEntryAgentInvocationFinished {
+		panic("tag mismatch")
+	}
+	return self.value.(AgentInvocationFinishedParameters)
+}
+func (self PublicOplogEntry) Suspend() Timestamp {
+	if self.tag != PublicOplogEntrySuspend {
+		panic("tag mismatch")
+	}
+	return self.value.(Timestamp)
+}
+func (self PublicOplogEntry) Error() ErrorParameters {
+	if self.tag != PublicOplogEntryError {
+		panic("tag mismatch")
+	}
+	return self.value.(ErrorParameters)
+}
+func (self PublicOplogEntry) NoOp() Timestamp {
+	if self.tag != PublicOplogEntryNoOp {
+		panic("tag mismatch")
+	}
+	return self.value.(Timestamp)
+}
+func (self PublicOplogEntry) Jump() JumpParameters {
+	if self.tag != PublicOplogEntryJump {
+		panic("tag mismatch")
+	}
+	return self.value.(JumpParameters)
+}
+func (self PublicOplogEntry) Interrupted() Timestamp {
+	if self.tag != PublicOplogEntryInterrupted {
+		panic("tag mismatch")
+	}
+	return self.value.(Timestamp)
+}
+func (self PublicOplogEntry) Exited() Timestamp {
+	if self.tag != PublicOplogEntryExited {
+		panic("tag mismatch")
+	}
+	return self.value.(Timestamp)
+}
+func (self PublicOplogEntry) BeginAtomicRegion() Timestamp {
+	if self.tag != PublicOplogEntryBeginAtomicRegion {
+		panic("tag mismatch")
+	}
+	return self.value.(Timestamp)
+}
+func (self PublicOplogEntry) EndAtomicRegion() EndAtomicRegionParameters {
+	if self.tag != PublicOplogEntryEndAtomicRegion {
+		panic("tag mismatch")
+	}
+	return self.value.(EndAtomicRegionParameters)
+}
+func (self PublicOplogEntry) PendingAgentInvocation() PendingAgentInvocationParameters {
+	if self.tag != PublicOplogEntryPendingAgentInvocation {
+		panic("tag mismatch")
+	}
+	return self.value.(PendingAgentInvocationParameters)
+}
+func (self PublicOplogEntry) PendingUpdate() PendingUpdateParameters {
+	if self.tag != PublicOplogEntryPendingUpdate {
+		panic("tag mismatch")
+	}
+	return self.value.(PendingUpdateParameters)
+}
+func (self PublicOplogEntry) SuccessfulUpdate() SuccessfulUpdateParameters {
+	if self.tag != PublicOplogEntrySuccessfulUpdate {
+		panic("tag mismatch")
+	}
+	return self.value.(SuccessfulUpdateParameters)
+}
+func (self PublicOplogEntry) FailedUpdate() FailedUpdateParameters {
+	if self.tag != PublicOplogEntryFailedUpdate {
+		panic("tag mismatch")
+	}
+	return self.value.(FailedUpdateParameters)
+}
+func (self PublicOplogEntry) GrowMemory() GrowMemoryParameters {
+	if self.tag != PublicOplogEntryGrowMemory {
+		panic("tag mismatch")
+	}
+	return self.value.(GrowMemoryParameters)
+}
+func (self PublicOplogEntry) FilesystemStorageUsageUpdate() FilesystemStorageUsageUpdateParameters {
+	if self.tag != PublicOplogEntryFilesystemStorageUsageUpdate {
+		panic("tag mismatch")
+	}
+	return self.value.(FilesystemStorageUsageUpdateParameters)
+}
+func (self PublicOplogEntry) CreateResource() CreateResourceParameters {
+	if self.tag != PublicOplogEntryCreateResource {
+		panic("tag mismatch")
+	}
+	return self.value.(CreateResourceParameters)
+}
+func (self PublicOplogEntry) DropResource() DropResourceParameters {
+	if self.tag != PublicOplogEntryDropResource {
+		panic("tag mismatch")
+	}
+	return self.value.(DropResourceParameters)
+}
+func (self PublicOplogEntry) Log() LogParameters {
+	if self.tag != PublicOplogEntryLog {
+		panic("tag mismatch")
+	}
+	return self.value.(LogParameters)
+}
+func (self PublicOplogEntry) Restart() Timestamp {
+	if self.tag != PublicOplogEntryRestart {
+		panic("tag mismatch")
+	}
+	return self.value.(Timestamp)
+}
+func (self PublicOplogEntry) ActivatePlugin() ActivatePluginParameters {
+	if self.tag != PublicOplogEntryActivatePlugin {
+		panic("tag mismatch")
+	}
+	return self.value.(ActivatePluginParameters)
+}
+func (self PublicOplogEntry) DeactivatePlugin() DeactivatePluginParameters {
+	if self.tag != PublicOplogEntryDeactivatePlugin {
+		panic("tag mismatch")
+	}
+	return self.value.(DeactivatePluginParameters)
+}
+func (self PublicOplogEntry) Revert() RevertParameters {
+	if self.tag != PublicOplogEntryRevert {
+		panic("tag mismatch")
+	}
+	return self.value.(RevertParameters)
+}
+func (self PublicOplogEntry) CancelPendingInvocation() CancelPendingInvocationParameters {
+	if self.tag != PublicOplogEntryCancelPendingInvocation {
+		panic("tag mismatch")
+	}
+	return self.value.(CancelPendingInvocationParameters)
+}
+func (self PublicOplogEntry) StartSpan() StartSpanParameters {
+	if self.tag != PublicOplogEntryStartSpan {
+		panic("tag mismatch")
+	}
+	return self.value.(StartSpanParameters)
+}
+func (self PublicOplogEntry) FinishSpan() FinishSpanParameters {
+	if self.tag != PublicOplogEntryFinishSpan {
+		panic("tag mismatch")
+	}
+	return self.value.(FinishSpanParameters)
+}
+func (self PublicOplogEntry) SetSpanAttribute() SetSpanAttributeParameters {
+	if self.tag != PublicOplogEntrySetSpanAttribute {
+		panic("tag mismatch")
+	}
+	return self.value.(SetSpanAttributeParameters)
+}
+func (self PublicOplogEntry) ChangePersistenceLevel() ChangePersistenceLevelParameters {
+	if self.tag != PublicOplogEntryChangePersistenceLevel {
+		panic("tag mismatch")
+	}
+	return self.value.(ChangePersistenceLevelParameters)
+}
+func (self PublicOplogEntry) BeginRemoteTransaction() BeginRemoteTransactionParameters {
+	if self.tag != PublicOplogEntryBeginRemoteTransaction {
+		panic("tag mismatch")
+	}
+	return self.value.(BeginRemoteTransactionParameters)
+}
+func (self PublicOplogEntry) PreCommitRemoteTransaction() RemoteTransactionParameters {
+	if self.tag != PublicOplogEntryPreCommitRemoteTransaction {
+		panic("tag mismatch")
+	}
+	return self.value.(RemoteTransactionParameters)
+}
+func (self PublicOplogEntry) PreRollbackRemoteTransaction() RemoteTransactionParameters {
+	if self.tag != PublicOplogEntryPreRollbackRemoteTransaction {
+		panic("tag mismatch")
+	}
+	return self.value.(RemoteTransactionParameters)
+}
+func (self PublicOplogEntry) CommittedRemoteTransaction() RemoteTransactionParameters {
+	if self.tag != PublicOplogEntryCommittedRemoteTransaction {
+		panic("tag mismatch")
+	}
+	return self.value.(RemoteTransactionParameters)
+}
+func (self PublicOplogEntry) RolledBackRemoteTransaction() RemoteTransactionParameters {
+	if self.tag != PublicOplogEntryRolledBackRemoteTransaction {
+		panic("tag mismatch")
+	}
+	return self.value.(RemoteTransactionParameters)
+}
+func (self PublicOplogEntry) Snapshot() SnapshotParameters {
+	if self.tag != PublicOplogEntrySnapshot {
+		panic("tag mismatch")
+	}
+	return self.value.(SnapshotParameters)
+}
+func (self PublicOplogEntry) OplogProcessorCheckpoint() OplogProcessorCheckpointParameters {
+	if self.tag != PublicOplogEntryOplogProcessorCheckpoint {
+		panic("tag mismatch")
+	}
+	return self.value.(OplogProcessorCheckpointParameters)
+}
+func (self PublicOplogEntry) SetRetryPolicy() SetRetryPolicyParameters {
+	if self.tag != PublicOplogEntrySetRetryPolicy {
+		panic("tag mismatch")
+	}
+	return self.value.(SetRetryPolicyParameters)
+}
+func (self PublicOplogEntry) RemoveRetryPolicy() RemoveRetryPolicyParameters {
+	if self.tag != PublicOplogEntryRemoveRetryPolicy {
+		panic("tag mismatch")
+	}
+	return self.value.(RemoveRetryPolicyParameters)
+}
+func (self PublicOplogEntry) CardEventQueued() CardEventQueuedParameters {
+	if self.tag != PublicOplogEntryCardEventQueued {
+		panic("tag mismatch")
+	}
+	return self.value.(CardEventQueuedParameters)
+}
+func (self PublicOplogEntry) CardInstalled() CardInstalledParameters {
+	if self.tag != PublicOplogEntryCardInstalled {
+		panic("tag mismatch")
+	}
+	return self.value.(CardInstalledParameters)
+}
+func (self PublicOplogEntry) CardInstallFailed() CardInstallFailedParameters {
+	if self.tag != PublicOplogEntryCardInstallFailed {
+		panic("tag mismatch")
+	}
+	return self.value.(CardInstallFailedParameters)
+}
+func (self PublicOplogEntry) CardRevoked() CardRevokedParameters {
+	if self.tag != PublicOplogEntryCardRevoked {
+		panic("tag mismatch")
+	}
+	return self.value.(CardRevokedParameters)
+}
+func (self PublicOplogEntry) CardExpired() CardExpiredParameters {
+	if self.tag != PublicOplogEntryCardExpired {
+		panic("tag mismatch")
+	}
+	return self.value.(CardExpiredParameters)
+}
+func (self PublicOplogEntry) HostStreamFrame() HostStreamFrameParameters {
+	if self.tag != PublicOplogEntryHostStreamFrame {
+		panic("tag mismatch")
+	}
+	return self.value.(HostStreamFrameParameters)
+}
+func (self PublicOplogEntry) CompletionDiscarded() CompletionDiscardedParameters {
+	if self.tag != PublicOplogEntryCompletionDiscarded {
+		panic("tag mismatch")
+	}
+	return self.value.(CompletionDiscardedParameters)
+}
+
+func MakePublicOplogEntryCreate(value CreateParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryCreate, value}
+}
+func MakePublicOplogEntryStart(value StartParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryStart, value}
+}
+func MakePublicOplogEntryEnd(value EndParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryEnd, value}
+}
+func MakePublicOplogEntryCancelled(value CancelledParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryCancelled, value}
+}
+func MakePublicOplogEntryAgentInvocationStarted(value AgentInvocationStartedParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryAgentInvocationStarted, value}
+}
+func MakePublicOplogEntryAgentInvocationFinished(value AgentInvocationFinishedParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryAgentInvocationFinished, value}
+}
+func MakePublicOplogEntrySuspend(value Timestamp) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntrySuspend, value}
+}
+func MakePublicOplogEntryError(value ErrorParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryError, value}
+}
+func MakePublicOplogEntryNoOp(value Timestamp) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryNoOp, value}
+}
+func MakePublicOplogEntryJump(value JumpParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryJump, value}
+}
+func MakePublicOplogEntryInterrupted(value Timestamp) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryInterrupted, value}
+}
+func MakePublicOplogEntryExited(value Timestamp) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryExited, value}
+}
+func MakePublicOplogEntryBeginAtomicRegion(value Timestamp) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryBeginAtomicRegion, value}
+}
+func MakePublicOplogEntryEndAtomicRegion(value EndAtomicRegionParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryEndAtomicRegion, value}
+}
+func MakePublicOplogEntryPendingAgentInvocation(value PendingAgentInvocationParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryPendingAgentInvocation, value}
+}
+func MakePublicOplogEntryPendingUpdate(value PendingUpdateParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryPendingUpdate, value}
+}
+func MakePublicOplogEntrySuccessfulUpdate(value SuccessfulUpdateParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntrySuccessfulUpdate, value}
+}
+func MakePublicOplogEntryFailedUpdate(value FailedUpdateParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryFailedUpdate, value}
+}
+func MakePublicOplogEntryGrowMemory(value GrowMemoryParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryGrowMemory, value}
+}
+func MakePublicOplogEntryFilesystemStorageUsageUpdate(value FilesystemStorageUsageUpdateParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryFilesystemStorageUsageUpdate, value}
+}
+func MakePublicOplogEntryCreateResource(value CreateResourceParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryCreateResource, value}
+}
+func MakePublicOplogEntryDropResource(value DropResourceParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryDropResource, value}
+}
+func MakePublicOplogEntryLog(value LogParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryLog, value}
+}
+func MakePublicOplogEntryRestart(value Timestamp) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryRestart, value}
+}
+func MakePublicOplogEntryActivatePlugin(value ActivatePluginParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryActivatePlugin, value}
+}
+func MakePublicOplogEntryDeactivatePlugin(value DeactivatePluginParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryDeactivatePlugin, value}
+}
+func MakePublicOplogEntryRevert(value RevertParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryRevert, value}
+}
+func MakePublicOplogEntryCancelPendingInvocation(value CancelPendingInvocationParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryCancelPendingInvocation, value}
+}
+func MakePublicOplogEntryStartSpan(value StartSpanParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryStartSpan, value}
+}
+func MakePublicOplogEntryFinishSpan(value FinishSpanParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryFinishSpan, value}
+}
+func MakePublicOplogEntrySetSpanAttribute(value SetSpanAttributeParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntrySetSpanAttribute, value}
+}
+func MakePublicOplogEntryChangePersistenceLevel(value ChangePersistenceLevelParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryChangePersistenceLevel, value}
+}
+func MakePublicOplogEntryBeginRemoteTransaction(value BeginRemoteTransactionParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryBeginRemoteTransaction, value}
+}
+func MakePublicOplogEntryPreCommitRemoteTransaction(value RemoteTransactionParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryPreCommitRemoteTransaction, value}
+}
+func MakePublicOplogEntryPreRollbackRemoteTransaction(value RemoteTransactionParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryPreRollbackRemoteTransaction, value}
+}
+func MakePublicOplogEntryCommittedRemoteTransaction(value RemoteTransactionParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryCommittedRemoteTransaction, value}
+}
+func MakePublicOplogEntryRolledBackRemoteTransaction(value RemoteTransactionParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryRolledBackRemoteTransaction, value}
+}
+func MakePublicOplogEntrySnapshot(value SnapshotParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntrySnapshot, value}
+}
+func MakePublicOplogEntryOplogProcessorCheckpoint(value OplogProcessorCheckpointParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryOplogProcessorCheckpoint, value}
+}
+func MakePublicOplogEntrySetRetryPolicy(value SetRetryPolicyParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntrySetRetryPolicy, value}
+}
+func MakePublicOplogEntryRemoveRetryPolicy(value RemoveRetryPolicyParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryRemoveRetryPolicy, value}
+}
+func MakePublicOplogEntryCardEventQueued(value CardEventQueuedParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryCardEventQueued, value}
+}
+func MakePublicOplogEntryCardInstalled(value CardInstalledParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryCardInstalled, value}
+}
+func MakePublicOplogEntryCardInstallFailed(value CardInstallFailedParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryCardInstallFailed, value}
+}
+func MakePublicOplogEntryCardRevoked(value CardRevokedParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryCardRevoked, value}
+}
+func MakePublicOplogEntryCardExpired(value CardExpiredParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryCardExpired, value}
+}
+func MakePublicOplogEntryHostStreamFrame(value HostStreamFrameParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryHostStreamFrame, value}
+}
+func MakePublicOplogEntryCompletionDiscarded(value CompletionDiscardedParameters) PublicOplogEntry {
+	return PublicOplogEntry{PublicOplogEntryCompletionDiscarded, value}
+}
+
+//go:wasmimport golem:api/oplog@1.5.0 [resource-drop]get-oplog
+func resourceDropGetOplog(handle int32)
+
+type GetOplog struct {
+	handle *witRuntime.Handle
+}
+
+func (self *GetOplog) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *GetOplog) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *GetOplog) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *GetOplog) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropGetOplog(handle)
+	}
+}
+
+func GetOplogFromOwnHandle(handleValue int32) *GetOplog {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &GetOplog{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropGetOplog(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func GetOplogFromBorrowHandle(handleValue int32) *GetOplog {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &GetOplog{handle}
+}
+
+//go:wasmimport golem:api/oplog@1.5.0 [resource-drop]search-oplog
+func resourceDropSearchOplog(handle int32)
+
+type SearchOplog struct {
+	handle *witRuntime.Handle
+}
+
+func (self *SearchOplog) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *SearchOplog) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *SearchOplog) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *SearchOplog) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropSearchOplog(handle)
+	}
+}
+
+func SearchOplogFromOwnHandle(handleValue int32) *SearchOplog {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &SearchOplog{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropSearchOplog(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func SearchOplogFromBorrowHandle(handleValue int32) *SearchOplog {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &SearchOplog{handle}
+}
+
+//go:wasmimport golem:api/oplog@1.5.0 enrich-oplog-entries
+func wasm_import_enrich_oplog_entries(arg0 int64, arg1 int64, arg2 int64, arg3 int64, arg4 uintptr, arg5 uint32, arg6 uintptr, arg7 uint32, arg8 int64, arg9 uintptr)
+
+func EnrichOplogEntries(environmentId golem_api_host.EnvironmentId, agentId golem_core_types.AgentId, entries []witTypes.Tuple2[uint64, OplogEntry], componentRevision uint64) witTypes.Result[[]PublicOplogEntry, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData((agentId).AgentId))
+	pinner.Pin(utf8)
+	slice218 := entries
+	length220 := uint32(len(slice218))
+	result219 := witRuntime.Allocate(pinner, uintptr(length220*(176+10*4)), 8)
+	for index, element := range slice218 {
+		base := unsafe.Add(result219, index*(176+10*4))
+		*(*int64)(unsafe.Add(unsafe.Pointer(base), 0)) = int64((element).F0)
+
+		switch (element).F1.Tag() {
+		case OplogEntryCreate:
+			payload := (element).F1.Create()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(((((payload).AgentId).ComponentId).Uuid).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64(((((payload).AgentId).ComponentId).Uuid).LowBits)
+			utf80 := unsafe.Pointer(unsafe.StringData(((payload).AgentId).AgentId))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 1*4))) = uint32(uint32(len(((payload).AgentId).AgentId)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48)) = uint32(uintptr(uintptr(utf80)))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4))) = int8(int32((payload).AgentMode))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4))) = int64((payload).ComponentRevision)
+			slice := (payload).Env
+			length := uint32(len(slice))
+			result := witRuntime.Allocate(pinner, uintptr(length*(4*4)), 4)
+			for index, element := range slice {
+				base := unsafe.Add(result, index*(4*4))
+				utf81 := unsafe.Pointer(unsafe.StringData((element).F0))
+				pinner.Pin(utf81)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).F0)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf81)))
+				utf82 := unsafe.Pointer(unsafe.StringData((element).F1))
+				pinner.Pin(utf82)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).F1)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf82)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 3*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uintptr(uintptr(result)))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 4*4))) = int64((((payload).EnvironmentId).Uuid).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (72 + 4*4))) = int64((((payload).EnvironmentId).Uuid).LowBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (80 + 4*4))) = int64((((payload).CreatedBy).Uuid).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (88 + 4*4))) = int64((((payload).CreatedBy).Uuid).LowBits)
+
+			switch (payload).Parent.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (96 + 4*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Parent.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (96 + 4*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (104 + 4*4))) = int64((((payload).ComponentId).Uuid).HighBits)
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (112 + 4*4))) = int64((((payload).ComponentId).Uuid).LowBits)
+				utf83 := unsafe.Pointer(unsafe.StringData((payload).AgentId))
+				pinner.Pin(utf83)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (120 + 5*4))) = uint32(uint32(len((payload).AgentId)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (120 + 4*4))) = uint32(uintptr(uintptr(utf83)))
+
+			default:
+				panic("unreachable")
+			}
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (120 + 6*4))) = int64((payload).ComponentSize)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (128 + 6*4))) = int64((payload).InitialTotalLinearMemorySize)
+			slice4 := (payload).InitialActivePlugins
+			length6 := uint32(len(slice4))
+			result5 := witRuntime.Allocate(pinner, uintptr(length6*16), 8)
+			for index, element := range slice4 {
+				base := unsafe.Add(result5, index*16)
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 0)) = int64(((element).Uuid).HighBits)
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(((element).Uuid).LowBits)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (136 + 7*4))) = uint32(length6)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (136 + 6*4))) = uint32(uintptr(uintptr(result5)))
+			slice42 := (payload).LocalAgentConfig
+			length44 := uint32(len(slice42))
+			result43 := witRuntime.Allocate(pinner, uintptr(length44*(5*4)), 4)
+			for index, element := range slice42 {
+				base := unsafe.Add(result43, index*(5*4))
+				slice8 := (element).Path
+				length10 := uint32(len(slice8))
+				result9 := witRuntime.Allocate(pinner, uintptr(length10*(2*4)), 4)
+				for index, element := range slice8 {
+					base := unsafe.Add(result9, index*(2*4))
+					utf87 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf87)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf87)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(length10)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(result9)))
+				slice39 := ((element).Value).ValueNodes
+				length41 := uint32(len(slice39))
+				result40 := witRuntime.Allocate(pinner, uintptr(length41*(16+4*4)), 8)
+				for index, element := range slice39 {
+					base := unsafe.Add(result40, index*(16+4*4))
+
+					switch element.Tag() {
+					case golem_core_types.SchemaValueNodeBoolValue:
+						payload := element.BoolValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+						var result11 int32
+						if payload {
+							result11 = 1
+						} else {
+							result11 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result11)
+
+					case golem_core_types.SchemaValueNodeS8Value:
+						payload := element.S8Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+					case golem_core_types.SchemaValueNodeS16Value:
+						payload := element.S16Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+						*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+					case golem_core_types.SchemaValueNodeS32Value:
+						payload := element.S32Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeS64Value:
+						payload := element.S64Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeU8Value:
+						payload := element.U8Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+					case golem_core_types.SchemaValueNodeU16Value:
+						payload := element.U16Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+						*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+					case golem_core_types.SchemaValueNodeU32Value:
+						payload := element.U32Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+					case golem_core_types.SchemaValueNodeU64Value:
+						payload := element.U64Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+					case golem_core_types.SchemaValueNodeF32Value:
+						payload := element.F32Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+						*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeF64Value:
+						payload := element.F64Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+						*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeCharValue:
+						payload := element.CharValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+					case golem_core_types.SchemaValueNodeStringValue:
+						payload := element.StringValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+						utf812 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf812)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf812)))
+
+					case golem_core_types.SchemaValueNodeRecordValue:
+						payload := element.RecordValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+						slice13 := payload
+						length15 := uint32(len(slice13))
+						result14 := witRuntime.Allocate(pinner, uintptr(length15*4), 4)
+						for index, element := range slice13 {
+							base := unsafe.Add(result14, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length15)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result14)))
+
+					case golem_core_types.SchemaValueNodeVariantValue:
+						payload := element.VariantValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).Case)
+
+						switch (payload).Payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeEnumValue:
+						payload := element.EnumValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+					case golem_core_types.SchemaValueNodeFlagsValue:
+						payload := element.FlagsValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+						slice17 := payload
+						length19 := uint32(len(slice17))
+						result18 := witRuntime.Allocate(pinner, uintptr(length19*1), 1)
+						for index, element := range slice17 {
+							base := unsafe.Add(result18, index*1)
+							var result16 int32
+							if element {
+								result16 = 1
+							} else {
+								result16 = 0
+							}
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result16)
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length19)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result18)))
+
+					case golem_core_types.SchemaValueNodeTupleValue:
+						payload := element.TupleValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+						slice20 := payload
+						length22 := uint32(len(slice20))
+						result21 := witRuntime.Allocate(pinner, uintptr(length22*4), 4)
+						for index, element := range slice20 {
+							base := unsafe.Add(result21, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length22)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result21)))
+
+					case golem_core_types.SchemaValueNodeListValue:
+						payload := element.ListValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+						slice23 := payload
+						length25 := uint32(len(slice23))
+						result24 := witRuntime.Allocate(pinner, uintptr(length25*4), 4)
+						for index, element := range slice23 {
+							base := unsafe.Add(result24, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length25)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result24)))
+
+					case golem_core_types.SchemaValueNodeFixedListValue:
+						payload := element.FixedListValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+						slice26 := payload
+						length28 := uint32(len(slice26))
+						result27 := witRuntime.Allocate(pinner, uintptr(length28*4), 4)
+						for index, element := range slice26 {
+							base := unsafe.Add(result27, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length28)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result27)))
+
+					case golem_core_types.SchemaValueNodeMapValue:
+						payload := element.MapValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+						slice29 := payload
+						length31 := uint32(len(slice29))
+						result30 := witRuntime.Allocate(pinner, uintptr(length31*8), 4)
+						for index, element := range slice29 {
+							base := unsafe.Add(result30, index*8)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).Key
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (element).Value
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length31)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result30)))
+
+					case golem_core_types.SchemaValueNodeOptionValue:
+						payload := element.OptionValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeResultValue:
+						payload := element.ResultValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+
+						switch payload.Tag() {
+						case golem_core_types.ResultValuePayloadOkValue:
+							payload := payload.OkValue()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+							switch payload.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := payload.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+								*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+							default:
+								panic("unreachable")
+							}
+
+						case golem_core_types.ResultValuePayloadErrValue:
+							payload := payload.ErrValue()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := payload.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+								*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeTextValue:
+						payload := element.TextValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+						utf832 := unsafe.Pointer(unsafe.StringData((payload).Text))
+						pinner.Pin(utf832)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf832)))
+
+						switch (payload).Language.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Language.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+							utf833 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf833)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf833)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeBinaryValue:
+						payload := element.BinaryValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+						data := unsafe.Pointer(unsafe.SliceData((payload).Bytes))
+						pinner.Pin(data)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+						switch (payload).MimeType.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MimeType.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+							utf834 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf834)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf834)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodePathValue:
+						payload := element.PathValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+						utf835 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf835)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf835)))
+
+					case golem_core_types.SchemaValueNodeUrlValue:
+						payload := element.UrlValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+						utf836 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf836)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf836)))
+
+					case golem_core_types.SchemaValueNodeDatetimeValue:
+						payload := element.DatetimeValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Seconds
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = int32((payload).Nanoseconds)
+
+					case golem_core_types.SchemaValueNodeDurationValue:
+						payload := element.DurationValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Nanoseconds
+
+					case golem_core_types.SchemaValueNodeQuantityValueNode:
+						payload := element.QuantityValueNode()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Mantissa
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Scale
+						utf837 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+						pinner.Pin(utf837)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uint32(len((payload).Unit)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))) = uint32(uintptr(uintptr(utf837)))
+
+					case golem_core_types.SchemaValueNodeUnionValue:
+						payload := element.UnionValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+						utf838 := unsafe.Pointer(unsafe.StringData((payload).Tag))
+						pinner.Pin(utf838)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf838)))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Body
+
+					case golem_core_types.SchemaValueNodeSecretValue:
+						payload := element.SecretValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+					case golem_core_types.SchemaValueNodeQuotaTokenHandle:
+						payload := element.QuotaTokenHandle()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(length41)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(result40)))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = ((element).Value).Root
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (136 + 9*4))) = uint32(length44)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (136 + 8*4))) = uint32(uintptr(uintptr(result43)))
+
+			switch (payload).OriginalPhantomId.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (136 + 10*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).OriginalPhantomId.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (136 + 10*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (144 + 10*4))) = int64((payload).HighBits)
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (152 + 10*4))) = int64((payload).LowBits)
+
+			default:
+				panic("unreachable")
+			}
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (160 + 10*4))) = int64(((payload).InstanceId).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (168 + 10*4))) = int64(((payload).InstanceId).LowBits)
+
+		case OplogEntryStart:
+			payload := (element).F1.Start()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+
+			switch (payload).ParentStartIndex.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).ParentStartIndex.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64(payload)
+
+			default:
+				panic("unreachable")
+			}
+			utf845 := unsafe.Pointer(unsafe.StringData((payload).FunctionName))
+			pinner.Pin(utf845)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 1*4))) = uint32(uint32(len((payload).FunctionName)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48)) = uint32(uintptr(uintptr(utf845)))
+
+			switch (payload).Request.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Request.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4))) = int8(int32(1))
+
+				switch payload.Tag() {
+				case OplogPayloadInline:
+					payload := payload.Inline()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4))) = int8(int32(0))
+					data46 := unsafe.Pointer(unsafe.SliceData(payload))
+					pinner.Pin(data46)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 3*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uintptr(uintptr(data46)))
+
+				case OplogPayloadExternal:
+					payload := payload.External()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4))) = int8(int32(1))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = int64(((payload).PayloadId).HighBits)
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), (72 + 2*4))) = int64(((payload).PayloadId).LowBits)
+					data47 := unsafe.Pointer(unsafe.SliceData((payload).Md5Hash))
+					pinner.Pin(data47)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 3*4))) = uint32(uint32(len((payload).Md5Hash)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 2*4))) = uint32(uintptr(uintptr(data47)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).DurableFunctionType.Tag() {
+			case WrappedFunctionTypeReadLocal:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (80 + 4*4))) = int8(int32(0))
+
+			case WrappedFunctionTypeWriteLocal:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (80 + 4*4))) = int8(int32(1))
+
+			case WrappedFunctionTypeReadRemote:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (80 + 4*4))) = int8(int32(2))
+
+			case WrappedFunctionTypeWriteRemote:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (80 + 4*4))) = int8(int32(3))
+
+			case WrappedFunctionTypeWriteRemoteBatched:
+				payload := (payload).DurableFunctionType.WriteRemoteBatched()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (80 + 4*4))) = int8(int32(4))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (88 + 4*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (88 + 4*4))) = int8(int32(1))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), (96 + 4*4))) = int64(payload)
+
+				default:
+					panic("unreachable")
+				}
+
+			case WrappedFunctionTypeWriteRemoteTransaction:
+				payload := (payload).DurableFunctionType.WriteRemoteTransaction()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (80 + 4*4))) = int8(int32(5))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (88 + 4*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (88 + 4*4))) = int8(int32(1))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), (96 + 4*4))) = int64(payload)
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case OplogEntryEnd:
+			payload := (element).F1.End()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).StartIndex)
+
+			switch (payload).Response.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Response.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+				switch payload.Tag() {
+				case OplogPayloadInline:
+					payload := payload.Inline()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+					data48 := unsafe.Pointer(unsafe.SliceData(payload))
+					pinner.Pin(data48)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 1*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 56)) = uint32(uintptr(uintptr(data48)))
+
+				case OplogPayloadExternal:
+					payload := payload.External()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(((payload).PayloadId).HighBits)
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 64)) = int64(((payload).PayloadId).LowBits)
+					data49 := unsafe.Pointer(unsafe.SliceData((payload).Md5Hash))
+					pinner.Pin(data49)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (72 + 1*4))) = uint32(uint32(len((payload).Md5Hash)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 72)) = uint32(uintptr(uintptr(data49)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+			var result50 int32
+			if (payload).ForcedCommit {
+				result50 = 1
+			} else {
+				result50 = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (72 + 2*4))) = int8(result50)
+
+		case OplogEntryCancelled:
+			payload := (element).F1.Cancelled()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(3))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).StartIndex)
+
+			switch (payload).Partial.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Partial.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+				switch payload.Tag() {
+				case OplogPayloadInline:
+					payload := payload.Inline()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+					data51 := unsafe.Pointer(unsafe.SliceData(payload))
+					pinner.Pin(data51)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 1*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 56)) = uint32(uintptr(uintptr(data51)))
+
+				case OplogPayloadExternal:
+					payload := payload.External()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(((payload).PayloadId).HighBits)
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 64)) = int64(((payload).PayloadId).LowBits)
+					data52 := unsafe.Pointer(unsafe.SliceData((payload).Md5Hash))
+					pinner.Pin(data52)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (72 + 1*4))) = uint32(uint32(len((payload).Md5Hash)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 72)) = uint32(uintptr(uintptr(data52)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case OplogEntryAgentInvocationStarted:
+			payload := (element).F1.AgentInvocationStarted()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(4))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			utf853 := unsafe.Pointer(unsafe.StringData((payload).IdempotencyKey))
+			pinner.Pin(utf853)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))) = uint32(uint32(len((payload).IdempotencyKey)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32)) = uint32(uintptr(uintptr(utf853)))
+
+			switch (payload).Payload.Tag() {
+			case OplogPayloadInline:
+				payload := (payload).Payload.Inline()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))) = int8(int32(0))
+				data54 := unsafe.Pointer(unsafe.SliceData(payload))
+				pinner.Pin(data54)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))) = uint32(uintptr(uintptr(data54)))
+
+			case OplogPayloadExternal:
+				payload := (payload).Payload.External()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))) = int64(((payload).PayloadId).HighBits)
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4))) = int64(((payload).PayloadId).LowBits)
+				data55 := unsafe.Pointer(unsafe.SliceData((payload).Md5Hash))
+				pinner.Pin(data55)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 3*4))) = uint32(uint32(len((payload).Md5Hash)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4))) = uint32(uintptr(uintptr(data55)))
+
+			default:
+				panic("unreachable")
+			}
+			utf856 := unsafe.Pointer(unsafe.StringData((payload).TraceId))
+			pinner.Pin(utf856)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 5*4))) = uint32(uint32(len((payload).TraceId)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 4*4))) = uint32(uintptr(uintptr(utf856)))
+			slice58 := (payload).TraceStates
+			length60 := uint32(len(slice58))
+			result59 := witRuntime.Allocate(pinner, uintptr(length60*(2*4)), 4)
+			for index, element := range slice58 {
+				base := unsafe.Add(result59, index*(2*4))
+				utf857 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf857)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf857)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 7*4))) = uint32(length60)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 6*4))) = uint32(uintptr(uintptr(result59)))
+			slice70 := (payload).InvocationContext
+			length72 := uint32(len(slice70))
+			result71 := witRuntime.Allocate(pinner, uintptr(length72*(56+6*4)), 8)
+			for index, element := range slice70 {
+				base := unsafe.Add(result71, index*(56+6*4))
+
+				switch element.Tag() {
+				case SpanDataLocalSpan:
+					payload := element.LocalSpan()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+					utf861 := unsafe.Pointer(unsafe.StringData((payload).SpanId))
+					pinner.Pin(utf861)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).SpanId)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf861)))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = ((payload).Start).Seconds
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int32(((payload).Start).Nanoseconds)
+
+					switch (payload).Parent.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Parent.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4))) = int8(int32(1))
+						utf862 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf862)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = uint32(uintptr(uintptr(utf862)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).LinkedContext.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).LinkedContext.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+					slice65 := (payload).Attributes
+					length67 := uint32(len(slice65))
+					result66 := witRuntime.Allocate(pinner, uintptr(length67*(5*4)), 4)
+					for index, element := range slice65 {
+						base := unsafe.Add(result66, index*(5*4))
+						utf863 := unsafe.Pointer(unsafe.StringData((element).Key))
+						pinner.Pin(utf863)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Key)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf863)))
+
+						switch (element).Value.Tag() {
+						case golem_api_context.AttributeValueString:
+							payload := (element).Value.String()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+							utf864 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf864)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf864)))
+
+						default:
+							panic("unreachable")
+						}
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))) = uint32(length67)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))) = uint32(uintptr(uintptr(result66)))
+					var result68 int32
+					if (payload).Inherited {
+						result68 = 1
+					} else {
+						result68 = 0
+					}
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))) = int8(result68)
+
+				case SpanDataExternalSpan:
+					payload := element.ExternalSpan()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+					utf869 := unsafe.Pointer(unsafe.StringData((payload).SpanId))
+					pinner.Pin(utf869)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).SpanId)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf869)))
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4))) = uint32(length72)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = uint32(uintptr(uintptr(result71)))
+
+		case OplogEntryAgentInvocationFinished:
+			payload := (element).F1.AgentInvocationFinished()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(5))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+
+			switch (payload).Result.Tag() {
+			case OplogPayloadInline:
+				payload := (payload).Result.Inline()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(0))
+				data73 := unsafe.Pointer(unsafe.SliceData(payload))
+				pinner.Pin(data73)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)) = uint32(uintptr(uintptr(data73)))
+
+			case OplogPayloadExternal:
+				payload := (payload).Result.External()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64(((payload).PayloadId).HighBits)
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 48)) = int64(((payload).PayloadId).LowBits)
+				data74 := unsafe.Pointer(unsafe.SliceData((payload).Md5Hash))
+				pinner.Pin(data74)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 1*4))) = uint32(uint32(len((payload).Md5Hash)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 56)) = uint32(uintptr(uintptr(data74)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MethodName.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MethodName.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4))) = int8(int32(1))
+				utf875 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf875)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 3*4))) = uint32(uintptr(uintptr(utf875)))
+
+			default:
+				panic("unreachable")
+			}
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 4*4))) = (payload).ConsumedFuel
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (72 + 4*4))) = int64((payload).ComponentRevision)
+
+		case OplogEntrySuspend:
+			payload := (element).F1.Suspend()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(6))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+
+		case OplogEntryError:
+			payload := (element).F1.Error()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(7))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+
+			switch (payload).Error.Tag() {
+			case WorkerErrorUnknown:
+				payload := (payload).Error.Unknown()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(0))
+				utf876 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf876)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)) = uint32(uintptr(uintptr(utf876)))
+
+			case WorkerErrorInvalidRequest:
+				payload := (payload).Error.InvalidRequest()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(1))
+				utf877 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf877)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)) = uint32(uintptr(uintptr(utf877)))
+
+			case WorkerErrorStackOverflow:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(2))
+
+			case WorkerErrorOutOfMemory:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(3))
+
+			case WorkerErrorExceededMemoryLimit:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(4))
+
+			case WorkerErrorInternalError:
+				payload := (payload).Error.InternalError()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(5))
+				utf878 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf878)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)) = uint32(uintptr(uintptr(utf878)))
+
+			case WorkerErrorDeterministicTrap:
+				payload := (payload).Error.DeterministicTrap()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(6))
+				utf879 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf879)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)) = uint32(uintptr(uintptr(utf879)))
+
+			case WorkerErrorTransientError:
+				payload := (payload).Error.TransientError()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(7))
+				utf880 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf880)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)) = uint32(uintptr(uintptr(utf880)))
+
+			case WorkerErrorPermanentError:
+				payload := (payload).Error.PermanentError()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(8))
+				utf881 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf881)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)) = uint32(uintptr(uintptr(utf881)))
+
+			case WorkerErrorExceededTableLimit:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(9))
+
+			case WorkerErrorExceededHttpCallLimit:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(10))
+
+			case WorkerErrorExceededRpcCallLimit:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(11))
+
+			case WorkerErrorNodeOutOfFilesystemStorage:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(12))
+
+			case WorkerErrorAgentExceededFilesystemStorageLimit:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(13))
+
+			case WorkerErrorAgentTerminatedByQuota:
+				payload := (payload).Error.AgentTerminatedByQuota()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(14))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64((((payload).EnvironmentId).Uuid).HighBits)
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 48)) = int64((((payload).EnvironmentId).Uuid).LowBits)
+				utf882 := unsafe.Pointer(unsafe.StringData((payload).ResourceName))
+				pinner.Pin(utf882)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 1*4))) = uint32(uint32(len((payload).ResourceName)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 56)) = uint32(uintptr(uintptr(utf882)))
+
+			case WorkerErrorEphemeralSleepTooLong:
+				payload := (payload).Error.EphemeralSleepTooLong()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(15))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64((payload).RequestedNanos)
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 48)) = int64((payload).MaxNanos)
+
+			case WorkerErrorEphemeralFuelExhausted:
+				payload := (payload).Error.EphemeralFuelExhausted()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(16))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64((payload).OverdraftLimit)
+
+			case WorkerErrorEphemeralCannotSuspend:
+				payload := (payload).Error.EphemeralCannotSuspend()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(17))
+				utf883 := unsafe.Pointer(unsafe.StringData((payload).Reason))
+				pinner.Pin(utf883)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))) = uint32(uint32(len((payload).Reason)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)) = uint32(uintptr(uintptr(utf883)))
+
+			case WorkerErrorReadOnlyViolation:
+				payload := (payload).Error.ReadOnlyViolation()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(18))
+				utf884 := unsafe.Pointer(unsafe.StringData((payload).Method))
+				pinner.Pin(utf884)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))) = uint32(uint32(len((payload).Method)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)) = uint32(uintptr(uintptr(utf884)))
+				utf885 := unsafe.Pointer(unsafe.StringData((payload).HostFunction))
+				pinner.Pin(utf885)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))) = uint32(uint32(len((payload).HostFunction)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))) = uint32(uintptr(uintptr(utf885)))
+
+			default:
+				panic("unreachable")
+			}
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4))) = int64((payload).RetryFrom)
+			var result86 int32
+			if (payload).InsideAtomicRegion {
+				result86 = 1
+			} else {
+				result86 = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = int8(result86)
+
+			switch (payload).RetryPolicyState.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (64 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).RetryPolicyState.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (64 + 3*4))) = int8(int32(1))
+				slice88 := (payload).Nodes
+				length90 := uint32(len(slice88))
+				result89 := witRuntime.Allocate(pinner, uintptr(length90*16), 4)
+				for index, element := range slice88 {
+					base := unsafe.Add(result89, index*16)
+
+					switch element.Tag() {
+					case StateNodeCounter:
+						payload := element.Counter()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = int32(payload)
+
+					case StateNodeTerminal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+					case StateNodeWrapper:
+						payload := element.Wrapper()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = payload
+
+					case StateNodeCountBox:
+						payload := element.CountBox()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = int32((payload).Attempts)
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Inner
+
+					case StateNodeAndThen:
+						payload := element.AndThen()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (payload).Left
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Right
+						var result87 int32
+						if (payload).OnRight {
+							result87 = 1
+						} else {
+							result87 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(result87)
+
+					case StateNodePair:
+						payload := element.Pair()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (payload).Left
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Right
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 5*4))) = uint32(length90)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 4*4))) = uint32(uintptr(uintptr(result89)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case OplogEntryNoOp:
+			payload := (element).F1.NoOp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(8))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+
+		case OplogEntryJump:
+			payload := (element).F1.Jump()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(9))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(((payload).Jump).Start)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64(((payload).Jump).End)
+
+		case OplogEntryInterrupted:
+			payload := (element).F1.Interrupted()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(10))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+
+		case OplogEntryExited:
+			payload := (element).F1.Exited()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(11))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+
+		case OplogEntryBeginAtomicRegion:
+			payload := (element).F1.BeginAtomicRegion()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(12))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+
+		case OplogEntryEndAtomicRegion:
+			payload := (element).F1.EndAtomicRegion()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(13))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).BeginIndex)
+
+		case OplogEntryPendingAgentInvocation:
+			payload := (element).F1.PendingAgentInvocation()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(14))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			utf891 := unsafe.Pointer(unsafe.StringData((payload).IdempotencyKey))
+			pinner.Pin(utf891)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))) = uint32(uint32(len((payload).IdempotencyKey)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32)) = uint32(uintptr(uintptr(utf891)))
+
+			switch (payload).Payload.Tag() {
+			case OplogPayloadInline:
+				payload := (payload).Payload.Inline()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))) = int8(int32(0))
+				data92 := unsafe.Pointer(unsafe.SliceData(payload))
+				pinner.Pin(data92)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))) = uint32(uintptr(uintptr(data92)))
+
+			case OplogPayloadExternal:
+				payload := (payload).Payload.External()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))) = int64(((payload).PayloadId).HighBits)
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4))) = int64(((payload).PayloadId).LowBits)
+				data93 := unsafe.Pointer(unsafe.SliceData((payload).Md5Hash))
+				pinner.Pin(data93)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 3*4))) = uint32(uint32(len((payload).Md5Hash)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4))) = uint32(uintptr(uintptr(data93)))
+
+			default:
+				panic("unreachable")
+			}
+			utf894 := unsafe.Pointer(unsafe.StringData((payload).TraceId))
+			pinner.Pin(utf894)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 5*4))) = uint32(uint32(len((payload).TraceId)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 4*4))) = uint32(uintptr(uintptr(utf894)))
+			slice96 := (payload).TraceStates
+			length98 := uint32(len(slice96))
+			result97 := witRuntime.Allocate(pinner, uintptr(length98*(2*4)), 4)
+			for index, element := range slice96 {
+				base := unsafe.Add(result97, index*(2*4))
+				utf895 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf895)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf895)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 7*4))) = uint32(length98)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 6*4))) = uint32(uintptr(uintptr(result97)))
+			slice108 := (payload).InvocationContext
+			length110 := uint32(len(slice108))
+			result109 := witRuntime.Allocate(pinner, uintptr(length110*(56+6*4)), 8)
+			for index, element := range slice108 {
+				base := unsafe.Add(result109, index*(56+6*4))
+
+				switch element.Tag() {
+				case SpanDataLocalSpan:
+					payload := element.LocalSpan()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+					utf899 := unsafe.Pointer(unsafe.StringData((payload).SpanId))
+					pinner.Pin(utf899)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).SpanId)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf899)))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = ((payload).Start).Seconds
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int32(((payload).Start).Nanoseconds)
+
+					switch (payload).Parent.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Parent.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4))) = int8(int32(1))
+						utf8100 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8100)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = uint32(uintptr(uintptr(utf8100)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).LinkedContext.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).LinkedContext.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+					slice103 := (payload).Attributes
+					length105 := uint32(len(slice103))
+					result104 := witRuntime.Allocate(pinner, uintptr(length105*(5*4)), 4)
+					for index, element := range slice103 {
+						base := unsafe.Add(result104, index*(5*4))
+						utf8101 := unsafe.Pointer(unsafe.StringData((element).Key))
+						pinner.Pin(utf8101)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Key)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8101)))
+
+						switch (element).Value.Tag() {
+						case golem_api_context.AttributeValueString:
+							payload := (element).Value.String()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+							utf8102 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8102)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8102)))
+
+						default:
+							panic("unreachable")
+						}
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))) = uint32(length105)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))) = uint32(uintptr(uintptr(result104)))
+					var result106 int32
+					if (payload).Inherited {
+						result106 = 1
+					} else {
+						result106 = 0
+					}
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))) = int8(result106)
+
+				case SpanDataExternalSpan:
+					payload := element.ExternalSpan()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+					utf8107 := unsafe.Pointer(unsafe.StringData((payload).SpanId))
+					pinner.Pin(utf8107)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).SpanId)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8107)))
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4))) = uint32(length110)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = uint32(uintptr(uintptr(result109)))
+
+		case OplogEntryPendingUpdate:
+			payload := (element).F1.PendingUpdate()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(15))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+
+			switch (payload).Description.Tag() {
+			case RawUpdateDescriptionAutomatic:
+				payload := (payload).Description.Automatic()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(0))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64(payload)
+
+			case RawUpdateDescriptionSnapshotBased:
+				payload := (payload).Description.SnapshotBased()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64((payload).TargetRevision)
+
+				switch (payload).Payload.Tag() {
+				case OplogPayloadInline:
+					payload := (payload).Payload.Inline()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+					data111 := unsafe.Pointer(unsafe.SliceData(payload))
+					pinner.Pin(data111)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 1*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 56)) = uint32(uintptr(uintptr(data111)))
+
+				case OplogPayloadExternal:
+					payload := (payload).Payload.External()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(((payload).PayloadId).HighBits)
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 64)) = int64(((payload).PayloadId).LowBits)
+					data112 := unsafe.Pointer(unsafe.SliceData((payload).Md5Hash))
+					pinner.Pin(data112)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (72 + 1*4))) = uint32(uint32(len((payload).Md5Hash)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 72)) = uint32(uintptr(uintptr(data112)))
+
+				default:
+					panic("unreachable")
+				}
+				utf8113 := unsafe.Pointer(unsafe.StringData((payload).MimeType))
+				pinner.Pin(utf8113)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (72 + 3*4))) = uint32(uint32(len((payload).MimeType)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (72 + 2*4))) = uint32(uintptr(uintptr(utf8113)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case OplogEntrySuccessfulUpdate:
+			payload := (element).F1.SuccessfulUpdate()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(16))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).TargetRevision)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64((payload).NewComponentSize)
+			slice114 := (payload).NewActivePlugins
+			length116 := uint32(len(slice114))
+			result115 := witRuntime.Allocate(pinner, uintptr(length116*16), 8)
+			for index, element := range slice114 {
+				base := unsafe.Add(result115, index*16)
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 0)) = int64(((element).Uuid).HighBits)
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(((element).Uuid).LowBits)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 1*4))) = uint32(length116)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48)) = uint32(uintptr(uintptr(result115)))
+
+		case OplogEntryFailedUpdate:
+			payload := (element).F1.FailedUpdate()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(17))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).TargetRevision)
+
+			switch (payload).Details.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Details.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+				utf8117 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8117)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))) = uint32(uintptr(uintptr(utf8117)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case OplogEntryGrowMemory:
+			payload := (element).F1.GrowMemory()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(18))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).Delta)
+
+		case OplogEntryFilesystemStorageUsageUpdate:
+			payload := (element).F1.FilesystemStorageUsageUpdate()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(19))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = (payload).Delta
+
+		case OplogEntryCreateResource:
+			payload := (element).F1.CreateResource()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(20))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).Id)
+			utf8118 := unsafe.Pointer(unsafe.StringData(((payload).ResourceTypeId).Name))
+			pinner.Pin(utf8118)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))) = uint32(uint32(len(((payload).ResourceTypeId).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)) = uint32(uintptr(uintptr(utf8118)))
+			utf8119 := unsafe.Pointer(unsafe.StringData(((payload).ResourceTypeId).Owner))
+			pinner.Pin(utf8119)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))) = uint32(uint32(len(((payload).ResourceTypeId).Owner)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))) = uint32(uintptr(uintptr(utf8119)))
+
+		case OplogEntryDropResource:
+			payload := (element).F1.DropResource()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(21))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).Id)
+			utf8120 := unsafe.Pointer(unsafe.StringData(((payload).ResourceTypeId).Name))
+			pinner.Pin(utf8120)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))) = uint32(uint32(len(((payload).ResourceTypeId).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)) = uint32(uintptr(uintptr(utf8120)))
+			utf8121 := unsafe.Pointer(unsafe.StringData(((payload).ResourceTypeId).Owner))
+			pinner.Pin(utf8121)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))) = uint32(uint32(len(((payload).ResourceTypeId).Owner)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))) = uint32(uintptr(uintptr(utf8121)))
+
+		case OplogEntryLog:
+			payload := (element).F1.Log()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(22))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32((payload).Level))
+			utf8122 := unsafe.Pointer(unsafe.StringData((payload).Context))
+			pinner.Pin(utf8122)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))) = uint32(uint32(len((payload).Context)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))) = uint32(uintptr(uintptr(utf8122)))
+			utf8123 := unsafe.Pointer(unsafe.StringData((payload).Message))
+			pinner.Pin(utf8123)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))) = uint32(uint32(len((payload).Message)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))) = uint32(uintptr(uintptr(utf8123)))
+
+		case OplogEntryRestart:
+			payload := (element).F1.Restart()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(23))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+
+		case OplogEntryActivatePlugin:
+			payload := (element).F1.ActivatePlugin()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(24))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((((payload).PluginGrantId).Uuid).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64((((payload).PluginGrantId).Uuid).LowBits)
+
+		case OplogEntryDeactivatePlugin:
+			payload := (element).F1.DeactivatePlugin()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(25))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((((payload).PluginGrantId).Uuid).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64((((payload).PluginGrantId).Uuid).LowBits)
+
+		case OplogEntryRevert:
+			payload := (element).F1.Revert()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(26))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(((payload).DroppedRegion).Start)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64(((payload).DroppedRegion).End)
+
+		case OplogEntryCancelPendingInvocation:
+			payload := (element).F1.CancelPendingInvocation()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(27))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			utf8124 := unsafe.Pointer(unsafe.StringData((payload).IdempotencyKey))
+			pinner.Pin(utf8124)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))) = uint32(uint32(len((payload).IdempotencyKey)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32)) = uint32(uintptr(uintptr(utf8124)))
+
+		case OplogEntryStartSpan:
+			payload := (element).F1.StartSpan()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(28))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			utf8125 := unsafe.Pointer(unsafe.StringData((payload).SpanId))
+			pinner.Pin(utf8125)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))) = uint32(uint32(len((payload).SpanId)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32)) = uint32(uintptr(uintptr(utf8125)))
+
+			switch (payload).Parent.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Parent.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))) = int8(int32(1))
+				utf8126 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8126)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))) = uint32(uintptr(uintptr(utf8126)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).LinkedContextId.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).LinkedContextId.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4))) = int8(int32(1))
+				utf8127 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8127)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = uint32(uintptr(uintptr(utf8127)))
+
+			default:
+				panic("unreachable")
+			}
+			slice130 := (payload).Attributes
+			length132 := uint32(len(slice130))
+			result131 := witRuntime.Allocate(pinner, uintptr(length132*(5*4)), 4)
+			for index, element := range slice130 {
+				base := unsafe.Add(result131, index*(5*4))
+				utf8128 := unsafe.Pointer(unsafe.StringData((element).Key))
+				pinner.Pin(utf8128)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Key)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8128)))
+
+				switch (element).Value.Tag() {
+				case golem_api_context.AttributeValueString:
+					payload := (element).Value.String()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+					utf8129 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8129)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8129)))
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4))) = uint32(length132)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4))) = uint32(uintptr(uintptr(result131)))
+
+		case OplogEntryFinishSpan:
+			payload := (element).F1.FinishSpan()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(29))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			utf8133 := unsafe.Pointer(unsafe.StringData((payload).SpanId))
+			pinner.Pin(utf8133)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))) = uint32(uint32(len((payload).SpanId)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32)) = uint32(uintptr(uintptr(utf8133)))
+
+		case OplogEntrySetSpanAttribute:
+			payload := (element).F1.SetSpanAttribute()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(30))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			utf8134 := unsafe.Pointer(unsafe.StringData((payload).SpanId))
+			pinner.Pin(utf8134)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))) = uint32(uint32(len((payload).SpanId)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32)) = uint32(uintptr(uintptr(utf8134)))
+			utf8135 := unsafe.Pointer(unsafe.StringData((payload).Key))
+			pinner.Pin(utf8135)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))) = uint32(uint32(len((payload).Key)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))) = uint32(uintptr(uintptr(utf8135)))
+
+			switch (payload).Value.Tag() {
+			case golem_api_context.AttributeValueString:
+				payload := (payload).Value.String()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))) = int8(int32(0))
+				utf8136 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8136)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4))) = uint32(uintptr(uintptr(utf8136)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case OplogEntryChangePersistenceLevel:
+			payload := (element).F1.ChangePersistenceLevel()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(31))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+
+			switch (payload).PersistenceLevel.Tag() {
+			case golem_api_host.PersistenceLevelPersistNothing:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(0))
+
+			case golem_api_host.PersistenceLevelPersistRemoteSideEffects:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(1))
+
+			case golem_api_host.PersistenceLevelSmart:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case OplogEntryBeginRemoteTransaction:
+			payload := (element).F1.BeginRemoteTransaction()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(32))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			utf8137 := unsafe.Pointer(unsafe.StringData((payload).TransactionId))
+			pinner.Pin(utf8137)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))) = uint32(uint32(len((payload).TransactionId)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32)) = uint32(uintptr(uintptr(utf8137)))
+
+			switch (payload).OriginalBeginIndex.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).OriginalBeginIndex.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))) = int64(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case OplogEntryPreCommitRemoteTransaction:
+			payload := (element).F1.PreCommitRemoteTransaction()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(33))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).BeginIndex)
+
+		case OplogEntryPreRollbackRemoteTransaction:
+			payload := (element).F1.PreRollbackRemoteTransaction()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(34))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).BeginIndex)
+
+		case OplogEntryCommittedRemoteTransaction:
+			payload := (element).F1.CommittedRemoteTransaction()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(35))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).BeginIndex)
+
+		case OplogEntryRolledBackRemoteTransaction:
+			payload := (element).F1.RolledBackRemoteTransaction()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(36))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).BeginIndex)
+
+		case OplogEntrySnapshot:
+			payload := (element).F1.Snapshot()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(37))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+
+			switch (payload).Data.Tag() {
+			case OplogPayloadInline:
+				payload := (payload).Data.Inline()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(0))
+				data138 := unsafe.Pointer(unsafe.SliceData(payload))
+				pinner.Pin(data138)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)) = uint32(uintptr(uintptr(data138)))
+
+			case OplogPayloadExternal:
+				payload := (payload).Data.External()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64(((payload).PayloadId).HighBits)
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 48)) = int64(((payload).PayloadId).LowBits)
+				data139 := unsafe.Pointer(unsafe.SliceData((payload).Md5Hash))
+				pinner.Pin(data139)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 1*4))) = uint32(uint32(len((payload).Md5Hash)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 56)) = uint32(uintptr(uintptr(data139)))
+
+			default:
+				panic("unreachable")
+			}
+			utf8140 := unsafe.Pointer(unsafe.StringData((payload).MimeType))
+			pinner.Pin(utf8140)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 3*4))) = uint32(uint32(len((payload).MimeType)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4))) = uint32(uintptr(uintptr(utf8140)))
+
+		case OplogEntryOplogProcessorCheckpoint:
+			payload := (element).F1.OplogProcessorCheckpoint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(38))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((((payload).PluginGrantId).Uuid).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64((((payload).PluginGrantId).Uuid).LowBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 48)) = int64(((((payload).TargetAgentId).ComponentId).Uuid).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(((((payload).TargetAgentId).ComponentId).Uuid).LowBits)
+			utf8141 := unsafe.Pointer(unsafe.StringData(((payload).TargetAgentId).AgentId))
+			pinner.Pin(utf8141)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uint32(len(((payload).TargetAgentId).AgentId)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64)) = uint32(uintptr(uintptr(utf8141)))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = int64((payload).ConfirmedUpTo)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (72 + 2*4))) = int64((payload).SendingUpTo)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (80 + 2*4))) = int64((payload).LastBatchStart)
+
+		case OplogEntrySetRetryPolicy:
+			payload := (element).F1.SetRetryPolicy()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(39))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			utf8142 := unsafe.Pointer(unsafe.StringData(((payload).Policy).Name))
+			pinner.Pin(utf8142)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))) = uint32(uint32(len(((payload).Policy).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32)) = uint32(uintptr(uintptr(utf8142)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))) = int32(((payload).Policy).Priority)
+			slice174 := (((payload).Policy).Predicate).Nodes
+			length176 := uint32(len(slice174))
+			result175 := witRuntime.Allocate(pinner, uintptr(length176*(16+4*4)), 8)
+			for index, element := range slice174 {
+				base := unsafe.Add(result175, index*(16+4*4))
+
+				switch element.Tag() {
+				case golem_api_retry.PredicateNodePropEq:
+					payload := element.PropEq()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+					utf8143 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf8143)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8143)))
+
+					switch (payload).Value.Tag() {
+					case golem_api_retry.PredicateValueText:
+						payload := (payload).Value.Text()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+						utf8144 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8144)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf8144)))
+
+					case golem_api_retry.PredicateValueInteger:
+						payload := (payload).Value.Integer()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+					case golem_api_retry.PredicateValueBoolean:
+						payload := (payload).Value.Boolean()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+						var result145 int32
+						if payload {
+							result145 = 1
+						} else {
+							result145 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result145)
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_api_retry.PredicateNodePropNeq:
+					payload := element.PropNeq()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+					utf8146 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf8146)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8146)))
+
+					switch (payload).Value.Tag() {
+					case golem_api_retry.PredicateValueText:
+						payload := (payload).Value.Text()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+						utf8147 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8147)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf8147)))
+
+					case golem_api_retry.PredicateValueInteger:
+						payload := (payload).Value.Integer()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+					case golem_api_retry.PredicateValueBoolean:
+						payload := (payload).Value.Boolean()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+						var result148 int32
+						if payload {
+							result148 = 1
+						} else {
+							result148 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result148)
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_api_retry.PredicateNodePropGt:
+					payload := element.PropGt()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+					utf8149 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf8149)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8149)))
+
+					switch (payload).Value.Tag() {
+					case golem_api_retry.PredicateValueText:
+						payload := (payload).Value.Text()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+						utf8150 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8150)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf8150)))
+
+					case golem_api_retry.PredicateValueInteger:
+						payload := (payload).Value.Integer()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+					case golem_api_retry.PredicateValueBoolean:
+						payload := (payload).Value.Boolean()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+						var result151 int32
+						if payload {
+							result151 = 1
+						} else {
+							result151 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result151)
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_api_retry.PredicateNodePropGte:
+					payload := element.PropGte()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+					utf8152 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf8152)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8152)))
+
+					switch (payload).Value.Tag() {
+					case golem_api_retry.PredicateValueText:
+						payload := (payload).Value.Text()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+						utf8153 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8153)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf8153)))
+
+					case golem_api_retry.PredicateValueInteger:
+						payload := (payload).Value.Integer()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+					case golem_api_retry.PredicateValueBoolean:
+						payload := (payload).Value.Boolean()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+						var result154 int32
+						if payload {
+							result154 = 1
+						} else {
+							result154 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result154)
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_api_retry.PredicateNodePropLt:
+					payload := element.PropLt()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+					utf8155 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf8155)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8155)))
+
+					switch (payload).Value.Tag() {
+					case golem_api_retry.PredicateValueText:
+						payload := (payload).Value.Text()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+						utf8156 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8156)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf8156)))
+
+					case golem_api_retry.PredicateValueInteger:
+						payload := (payload).Value.Integer()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+					case golem_api_retry.PredicateValueBoolean:
+						payload := (payload).Value.Boolean()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+						var result157 int32
+						if payload {
+							result157 = 1
+						} else {
+							result157 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result157)
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_api_retry.PredicateNodePropLte:
+					payload := element.PropLte()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+					utf8158 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf8158)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8158)))
+
+					switch (payload).Value.Tag() {
+					case golem_api_retry.PredicateValueText:
+						payload := (payload).Value.Text()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+						utf8159 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8159)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf8159)))
+
+					case golem_api_retry.PredicateValueInteger:
+						payload := (payload).Value.Integer()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+					case golem_api_retry.PredicateValueBoolean:
+						payload := (payload).Value.Boolean()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+						var result160 int32
+						if payload {
+							result160 = 1
+						} else {
+							result160 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result160)
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_api_retry.PredicateNodePropExists:
+					payload := element.PropExists()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+					utf8161 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8161)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8161)))
+
+				case golem_api_retry.PredicateNodePropIn:
+					payload := element.PropIn()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+					utf8162 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf8162)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8162)))
+					slice165 := (payload).Values
+					length167 := uint32(len(slice165))
+					result166 := witRuntime.Allocate(pinner, uintptr(length167*(8+2*4)), 8)
+					for index, element := range slice165 {
+						base := unsafe.Add(result166, index*(8+2*4))
+
+						switch element.Tag() {
+						case golem_api_retry.PredicateValueText:
+							payload := element.Text()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+							utf8163 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8163)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8163)))
+
+						case golem_api_retry.PredicateValueInteger:
+							payload := element.Integer()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+						case golem_api_retry.PredicateValueBoolean:
+							payload := element.Boolean()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+							var result164 int32
+							if payload {
+								result164 = 1
+							} else {
+								result164 = 0
+							}
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result164)
+
+						default:
+							panic("unreachable")
+						}
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length167)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result166)))
+
+				case golem_api_retry.PredicateNodePropMatches:
+					payload := element.PropMatches()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+					utf8168 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf8168)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8168)))
+					utf8169 := unsafe.Pointer(unsafe.StringData((payload).Pattern))
+					pinner.Pin(utf8169)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Pattern)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8169)))
+
+				case golem_api_retry.PredicateNodePropStartsWith:
+					payload := element.PropStartsWith()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+					utf8170 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf8170)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8170)))
+					utf8171 := unsafe.Pointer(unsafe.StringData((payload).Pattern))
+					pinner.Pin(utf8171)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Pattern)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8171)))
+
+				case golem_api_retry.PredicateNodePropContains:
+					payload := element.PropContains()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+					utf8172 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf8172)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8172)))
+					utf8173 := unsafe.Pointer(unsafe.StringData((payload).Pattern))
+					pinner.Pin(utf8173)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Pattern)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8173)))
+
+				case golem_api_retry.PredicateNodePredAnd:
+					payload := element.PredAnd()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).F1
+
+				case golem_api_retry.PredicateNodePredOr:
+					payload := element.PredOr()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).F1
+
+				case golem_api_retry.PredicateNodePredNot:
+					payload := element.PredNot()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+				case golem_api_retry.PredicateNodePredTrue:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+
+				case golem_api_retry.PredicateNodePredFalse:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))) = uint32(length176)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))) = uint32(uintptr(uintptr(result175)))
+			slice211 := (((payload).Policy).Policy).Nodes
+			length213 := uint32(len(slice211))
+			result212 := witRuntime.Allocate(pinner, uintptr(length213*32), 8)
+			for index, element := range slice211 {
+				base := unsafe.Add(result212, index*32)
+
+				switch element.Tag() {
+				case golem_api_retry.PolicyNodePeriodic:
+					payload := element.Periodic()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+				case golem_api_retry.PolicyNodeExponential:
+					payload := element.Exponential()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).BaseDelay)
+					*(*float64)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Factor
+
+				case golem_api_retry.PolicyNodeFibonacci:
+					payload := element.Fibonacci()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).First)
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).Second)
+
+				case golem_api_retry.PolicyNodeImmediate:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+				case golem_api_retry.PolicyNodeNever:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+				case golem_api_retry.PolicyNodeCountBox:
+					payload := element.CountBox()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).MaxRetries)
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Inner
+
+				case golem_api_retry.PolicyNodeTimeBox:
+					payload := element.TimeBox()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).Limit)
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Inner
+
+				case golem_api_retry.PolicyNodeClampDelay:
+					payload := element.ClampDelay()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).MinDelay)
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).MaxDelay)
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Inner
+
+				case golem_api_retry.PolicyNodeAddDelay:
+					payload := element.AddDelay()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).Delay)
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Inner
+
+				case golem_api_retry.PolicyNodeJitter:
+					payload := element.Jitter()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+					*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Factor
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Inner
+
+				case golem_api_retry.PolicyNodeFilteredOn:
+					payload := element.FilteredOn()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+					slice208 := ((payload).Predicate).Nodes
+					length210 := uint32(len(slice208))
+					result209 := witRuntime.Allocate(pinner, uintptr(length210*(16+4*4)), 8)
+					for index, element := range slice208 {
+						base := unsafe.Add(result209, index*(16+4*4))
+
+						switch element.Tag() {
+						case golem_api_retry.PredicateNodePropEq:
+							payload := element.PropEq()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+							utf8177 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+							pinner.Pin(utf8177)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8177)))
+
+							switch (payload).Value.Tag() {
+							case golem_api_retry.PredicateValueText:
+								payload := (payload).Value.Text()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+								utf8178 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8178)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf8178)))
+
+							case golem_api_retry.PredicateValueInteger:
+								payload := (payload).Value.Integer()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+							case golem_api_retry.PredicateValueBoolean:
+								payload := (payload).Value.Boolean()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+								var result179 int32
+								if payload {
+									result179 = 1
+								} else {
+									result179 = 0
+								}
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result179)
+
+							default:
+								panic("unreachable")
+							}
+
+						case golem_api_retry.PredicateNodePropNeq:
+							payload := element.PropNeq()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+							utf8180 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+							pinner.Pin(utf8180)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8180)))
+
+							switch (payload).Value.Tag() {
+							case golem_api_retry.PredicateValueText:
+								payload := (payload).Value.Text()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+								utf8181 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8181)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf8181)))
+
+							case golem_api_retry.PredicateValueInteger:
+								payload := (payload).Value.Integer()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+							case golem_api_retry.PredicateValueBoolean:
+								payload := (payload).Value.Boolean()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+								var result182 int32
+								if payload {
+									result182 = 1
+								} else {
+									result182 = 0
+								}
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result182)
+
+							default:
+								panic("unreachable")
+							}
+
+						case golem_api_retry.PredicateNodePropGt:
+							payload := element.PropGt()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+							utf8183 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+							pinner.Pin(utf8183)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8183)))
+
+							switch (payload).Value.Tag() {
+							case golem_api_retry.PredicateValueText:
+								payload := (payload).Value.Text()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+								utf8184 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8184)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf8184)))
+
+							case golem_api_retry.PredicateValueInteger:
+								payload := (payload).Value.Integer()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+							case golem_api_retry.PredicateValueBoolean:
+								payload := (payload).Value.Boolean()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+								var result185 int32
+								if payload {
+									result185 = 1
+								} else {
+									result185 = 0
+								}
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result185)
+
+							default:
+								panic("unreachable")
+							}
+
+						case golem_api_retry.PredicateNodePropGte:
+							payload := element.PropGte()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+							utf8186 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+							pinner.Pin(utf8186)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8186)))
+
+							switch (payload).Value.Tag() {
+							case golem_api_retry.PredicateValueText:
+								payload := (payload).Value.Text()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+								utf8187 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8187)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf8187)))
+
+							case golem_api_retry.PredicateValueInteger:
+								payload := (payload).Value.Integer()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+							case golem_api_retry.PredicateValueBoolean:
+								payload := (payload).Value.Boolean()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+								var result188 int32
+								if payload {
+									result188 = 1
+								} else {
+									result188 = 0
+								}
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result188)
+
+							default:
+								panic("unreachable")
+							}
+
+						case golem_api_retry.PredicateNodePropLt:
+							payload := element.PropLt()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+							utf8189 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+							pinner.Pin(utf8189)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8189)))
+
+							switch (payload).Value.Tag() {
+							case golem_api_retry.PredicateValueText:
+								payload := (payload).Value.Text()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+								utf8190 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8190)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf8190)))
+
+							case golem_api_retry.PredicateValueInteger:
+								payload := (payload).Value.Integer()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+							case golem_api_retry.PredicateValueBoolean:
+								payload := (payload).Value.Boolean()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+								var result191 int32
+								if payload {
+									result191 = 1
+								} else {
+									result191 = 0
+								}
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result191)
+
+							default:
+								panic("unreachable")
+							}
+
+						case golem_api_retry.PredicateNodePropLte:
+							payload := element.PropLte()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+							utf8192 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+							pinner.Pin(utf8192)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8192)))
+
+							switch (payload).Value.Tag() {
+							case golem_api_retry.PredicateValueText:
+								payload := (payload).Value.Text()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+								utf8193 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8193)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf8193)))
+
+							case golem_api_retry.PredicateValueInteger:
+								payload := (payload).Value.Integer()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+							case golem_api_retry.PredicateValueBoolean:
+								payload := (payload).Value.Boolean()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+								var result194 int32
+								if payload {
+									result194 = 1
+								} else {
+									result194 = 0
+								}
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result194)
+
+							default:
+								panic("unreachable")
+							}
+
+						case golem_api_retry.PredicateNodePropExists:
+							payload := element.PropExists()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+							utf8195 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8195)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8195)))
+
+						case golem_api_retry.PredicateNodePropIn:
+							payload := element.PropIn()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+							utf8196 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+							pinner.Pin(utf8196)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8196)))
+							slice199 := (payload).Values
+							length201 := uint32(len(slice199))
+							result200 := witRuntime.Allocate(pinner, uintptr(length201*(8+2*4)), 8)
+							for index, element := range slice199 {
+								base := unsafe.Add(result200, index*(8+2*4))
+
+								switch element.Tag() {
+								case golem_api_retry.PredicateValueText:
+									payload := element.Text()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+									utf8197 := unsafe.Pointer(unsafe.StringData(payload))
+									pinner.Pin(utf8197)
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8197)))
+
+								case golem_api_retry.PredicateValueInteger:
+									payload := element.Integer()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+								case golem_api_retry.PredicateValueBoolean:
+									payload := element.Boolean()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+									var result198 int32
+									if payload {
+										result198 = 1
+									} else {
+										result198 = 0
+									}
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result198)
+
+								default:
+									panic("unreachable")
+								}
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length201)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result200)))
+
+						case golem_api_retry.PredicateNodePropMatches:
+							payload := element.PropMatches()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+							utf8202 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+							pinner.Pin(utf8202)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8202)))
+							utf8203 := unsafe.Pointer(unsafe.StringData((payload).Pattern))
+							pinner.Pin(utf8203)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Pattern)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8203)))
+
+						case golem_api_retry.PredicateNodePropStartsWith:
+							payload := element.PropStartsWith()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+							utf8204 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+							pinner.Pin(utf8204)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8204)))
+							utf8205 := unsafe.Pointer(unsafe.StringData((payload).Pattern))
+							pinner.Pin(utf8205)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Pattern)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8205)))
+
+						case golem_api_retry.PredicateNodePropContains:
+							payload := element.PropContains()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+							utf8206 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+							pinner.Pin(utf8206)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8206)))
+							utf8207 := unsafe.Pointer(unsafe.StringData((payload).Pattern))
+							pinner.Pin(utf8207)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Pattern)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8207)))
+
+						case golem_api_retry.PredicateNodePredAnd:
+							payload := element.PredAnd()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).F1
+
+						case golem_api_retry.PredicateNodePredOr:
+							payload := element.PredOr()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).F1
+
+						case golem_api_retry.PredicateNodePredNot:
+							payload := element.PredNot()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+						case golem_api_retry.PredicateNodePredTrue:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+
+						case golem_api_retry.PredicateNodePredFalse:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+
+						default:
+							panic("unreachable")
+						}
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length210)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result209)))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Inner
+
+				case golem_api_retry.PolicyNodeAndThen:
+					payload := element.AndThen()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).F1
+
+				case golem_api_retry.PolicyNodePolicyUnion:
+					payload := element.PolicyUnion()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).F1
+
+				case golem_api_retry.PolicyNodePolicyIntersect:
+					payload := element.PolicyIntersect()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).F1
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = uint32(length213)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4))) = uint32(uintptr(uintptr(result212)))
+
+		case OplogEntryRemoveRetryPolicy:
+			payload := (element).F1.RemoveRetryPolicy()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(40))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			utf8214 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf8214)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32)) = uint32(uintptr(uintptr(utf8214)))
+
+		case OplogEntryCardEventQueued:
+			payload := (element).F1.CardEventQueued()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(41))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+
+			switch (payload).Event.Tag() {
+			case QueuedCardEventInstallTag:
+				payload := (payload).Event.Install()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(0))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64((((payload).CardId).Uuid).HighBits)
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 48)) = int64((((payload).CardId).Uuid).LowBits)
+
+			case QueuedCardEventRevokeTag:
+				payload := (payload).Event.Revoke()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64((((payload).CardId).Uuid).HighBits)
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 48)) = int64((((payload).CardId).Uuid).LowBits)
+
+			default:
+				panic("unreachable")
+			}
+
+		case OplogEntryCardInstalled:
+			payload := (element).F1.CardInstalled()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(42))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+
+			switch (payload).QueuedEventIndex.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).QueuedEventIndex.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64(payload)
+
+			default:
+				panic("unreachable")
+			}
+			data215 := unsafe.Pointer(unsafe.SliceData((payload).Card))
+			pinner.Pin(data215)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 1*4))) = uint32(uint32(len((payload).Card)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48)) = uint32(uintptr(uintptr(data215)))
+
+		case OplogEntryCardInstallFailed:
+			payload := (element).F1.CardInstallFailed()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(43))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).QueuedEventIndex)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64((((payload).CardId).Uuid).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 48)) = int64((((payload).CardId).Uuid).LowBits)
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 56)) = int8(int32((payload).Reason))
+
+		case OplogEntryCardRevoked:
+			payload := (element).F1.CardRevoked()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(44))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).QueuedEventIndex)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64((((payload).CardId).Uuid).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 48)) = int64((((payload).CardId).Uuid).LowBits)
+
+		case OplogEntryCardExpired:
+			payload := (element).F1.CardExpired()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(45))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((((payload).CardId).Uuid).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)) = int64((((payload).CardId).Uuid).LowBits)
+
+		case OplogEntryHostStreamFrame:
+			payload := (element).F1.HostStreamFrame()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(46))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).ParentStartIndex)
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32((payload).Kind))
+
+			switch (payload).Payload.Tag() {
+			case OplogPayloadInline:
+				payload := (payload).Payload.Inline()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+				data216 := unsafe.Pointer(unsafe.SliceData(payload))
+				pinner.Pin(data216)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 1*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 56)) = uint32(uintptr(uintptr(data216)))
+
+			case OplogPayloadExternal:
+				payload := (payload).Payload.External()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(((payload).PayloadId).HighBits)
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 64)) = int64(((payload).PayloadId).LowBits)
+				data217 := unsafe.Pointer(unsafe.SliceData((payload).Md5Hash))
+				pinner.Pin(data217)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (72 + 1*4))) = uint32(uint32(len((payload).Md5Hash)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 72)) = uint32(uintptr(uintptr(data217)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case OplogEntryCompletionDiscarded:
+			payload := (element).F1.CompletionDiscarded()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(47))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = ((payload).Timestamp).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Timestamp).Nanoseconds)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64((payload).StartIndex)
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_enrich_oplog_entries(int64(((environmentId).Uuid).HighBits), int64(((environmentId).Uuid).LowBits), int64((((agentId).ComponentId).Uuid).HighBits), int64((((agentId).ComponentId).Uuid).LowBits), uintptr(utf8), uint32(len((agentId).AgentId)), uintptr(result219), length220, int64(componentRevision), returnArea)
+	var result2696 witTypes.Result[[]PublicOplogEntry, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		result2694 := make([]PublicOplogEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(168+10*4))
+			var variant2693 PublicOplogEntry
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+				value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+				result223 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 3*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 3*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4))))), index*(4*4))
+					value221 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value222 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result223 = append(result223, witTypes.Tuple2[string, string]{value221, value222})
+				}
+
+				var option witTypes.Option[golem_core_types.AgentId]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (88 + 4*4)))) {
+				case 0:
+
+					option = witTypes.None[golem_core_types.AgentId]()
+				case 1:
+					value224 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (112 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (112 + 5*4))))
+
+					option = witTypes.Some[golem_core_types.AgentId](golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (96 + 4*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (104 + 4*4))))}}, value224})
+				default:
+					panic("unreachable")
+				}
+				result230 := make([]PluginInstallationDescription, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (128 + 7*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (128 + 7*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (128 + 6*4))))), index*(24+6*4))
+					value225 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+					value226 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))))
+					result229 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 5*4))))), index*(4*4))
+						value227 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						value228 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+						result229 = append(result229, witTypes.Tuple2[string, string]{value227, value228})
+					}
+
+					result230 = append(result230, PluginInstallationDescription{EnvironmentPluginGrantId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value225, value226, result229})
+				}
+
+				result436 := make([]LocalAgentConfigEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (128 + 9*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (128 + 9*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (128 + 8*4))))), index*(10*4))
+					result232 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*(2*4))
+						value231 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result232 = append(result232, value231)
+					}
+
+					result407 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))), index*(56+22*4))
+						var variant395 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option238 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option238 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option233 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option233 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option233 = witTypes.Some[golem_core_types.NumericBound](variant)
+								default:
+									panic("unreachable")
+								}
+								var option235 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option235 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant234 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant234 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant234 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant234 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option235 = witTypes.Some[golem_core_types.NumericBound](variant234)
+								default:
+									panic("unreachable")
+								}
+								var option237 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option237 = witTypes.None[string]()
+								case 1:
+									value236 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option237 = witTypes.Some[string](value236)
+								default:
+									panic("unreachable")
+								}
+
+								option238 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option233, option235, option237})
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyS8Type(option238)
+
+						case 3:
+							var option245 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option245 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option240 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option240 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant239 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant239 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant239 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant239 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option240 = witTypes.Some[golem_core_types.NumericBound](variant239)
+								default:
+									panic("unreachable")
+								}
+								var option242 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option242 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant241 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant241 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant241 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant241 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option242 = witTypes.Some[golem_core_types.NumericBound](variant241)
+								default:
+									panic("unreachable")
+								}
+								var option244 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option244 = witTypes.None[string]()
+								case 1:
+									value243 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option244 = witTypes.Some[string](value243)
+								default:
+									panic("unreachable")
+								}
+
+								option245 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option240, option242, option244})
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyS16Type(option245)
+
+						case 4:
+							var option252 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option252 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option247 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option247 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant246 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant246 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant246 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant246 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option247 = witTypes.Some[golem_core_types.NumericBound](variant246)
+								default:
+									panic("unreachable")
+								}
+								var option249 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option249 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant248 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant248 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant248 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant248 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option249 = witTypes.Some[golem_core_types.NumericBound](variant248)
+								default:
+									panic("unreachable")
+								}
+								var option251 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option251 = witTypes.None[string]()
+								case 1:
+									value250 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option251 = witTypes.Some[string](value250)
+								default:
+									panic("unreachable")
+								}
+
+								option252 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option247, option249, option251})
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyS32Type(option252)
+
+						case 5:
+							var option259 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option259 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option254 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option254 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant253 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant253 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant253 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant253 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option254 = witTypes.Some[golem_core_types.NumericBound](variant253)
+								default:
+									panic("unreachable")
+								}
+								var option256 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option256 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant255 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant255 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant255 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant255 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option256 = witTypes.Some[golem_core_types.NumericBound](variant255)
+								default:
+									panic("unreachable")
+								}
+								var option258 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option258 = witTypes.None[string]()
+								case 1:
+									value257 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option258 = witTypes.Some[string](value257)
+								default:
+									panic("unreachable")
+								}
+
+								option259 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option254, option256, option258})
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyS64Type(option259)
+
+						case 6:
+							var option266 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option266 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option261 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option261 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant260 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant260 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant260 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant260 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option261 = witTypes.Some[golem_core_types.NumericBound](variant260)
+								default:
+									panic("unreachable")
+								}
+								var option263 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option263 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant262 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant262 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant262 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant262 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option263 = witTypes.Some[golem_core_types.NumericBound](variant262)
+								default:
+									panic("unreachable")
+								}
+								var option265 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option265 = witTypes.None[string]()
+								case 1:
+									value264 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option265 = witTypes.Some[string](value264)
+								default:
+									panic("unreachable")
+								}
+
+								option266 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option261, option263, option265})
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyU8Type(option266)
+
+						case 7:
+							var option273 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option273 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option268 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option268 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant267 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant267 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant267 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant267 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option268 = witTypes.Some[golem_core_types.NumericBound](variant267)
+								default:
+									panic("unreachable")
+								}
+								var option270 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option270 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant269 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant269 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant269 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant269 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option270 = witTypes.Some[golem_core_types.NumericBound](variant269)
+								default:
+									panic("unreachable")
+								}
+								var option272 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option272 = witTypes.None[string]()
+								case 1:
+									value271 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option272 = witTypes.Some[string](value271)
+								default:
+									panic("unreachable")
+								}
+
+								option273 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option268, option270, option272})
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyU16Type(option273)
+
+						case 8:
+							var option280 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option280 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option275 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option275 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant274 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant274 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant274 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant274 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option275 = witTypes.Some[golem_core_types.NumericBound](variant274)
+								default:
+									panic("unreachable")
+								}
+								var option277 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option277 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant276 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant276 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant276 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant276 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option277 = witTypes.Some[golem_core_types.NumericBound](variant276)
+								default:
+									panic("unreachable")
+								}
+								var option279 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option279 = witTypes.None[string]()
+								case 1:
+									value278 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option279 = witTypes.Some[string](value278)
+								default:
+									panic("unreachable")
+								}
+
+								option280 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option275, option277, option279})
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyU32Type(option280)
+
+						case 9:
+							var option287 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option287 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option282 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option282 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant281 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant281 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant281 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant281 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option282 = witTypes.Some[golem_core_types.NumericBound](variant281)
+								default:
+									panic("unreachable")
+								}
+								var option284 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option284 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant283 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant283 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant283 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant283 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option284 = witTypes.Some[golem_core_types.NumericBound](variant283)
+								default:
+									panic("unreachable")
+								}
+								var option286 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option286 = witTypes.None[string]()
+								case 1:
+									value285 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option286 = witTypes.Some[string](value285)
+								default:
+									panic("unreachable")
+								}
+
+								option287 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option282, option284, option286})
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyU64Type(option287)
+
+						case 10:
+							var option294 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option294 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option289 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option289 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant288 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant288 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant288 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant288 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option289 = witTypes.Some[golem_core_types.NumericBound](variant288)
+								default:
+									panic("unreachable")
+								}
+								var option291 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option291 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant290 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant290 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant290 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant290 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option291 = witTypes.Some[golem_core_types.NumericBound](variant290)
+								default:
+									panic("unreachable")
+								}
+								var option293 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option293 = witTypes.None[string]()
+								case 1:
+									value292 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option293 = witTypes.Some[string](value292)
+								default:
+									panic("unreachable")
+								}
+
+								option294 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option289, option291, option293})
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyF32Type(option294)
+
+						case 11:
+							var option301 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option301 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option296 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option296 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant295 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant295 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant295 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant295 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option296 = witTypes.Some[golem_core_types.NumericBound](variant295)
+								default:
+									panic("unreachable")
+								}
+								var option298 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option298 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant297 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant297 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant297 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant297 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option298 = witTypes.Some[golem_core_types.NumericBound](variant297)
+								default:
+									panic("unreachable")
+								}
+								var option300 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option300 = witTypes.None[string]()
+								case 1:
+									value299 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option300 = witTypes.Some[string](value299)
+								default:
+									panic("unreachable")
+								}
+
+								option301 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option296, option298, option300})
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyF64Type(option301)
+
+						case 12:
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result314 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value302 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option304 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option304 = witTypes.None[string]()
+								case 1:
+									value303 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option304 = witTypes.Some[string](value303)
+								default:
+									panic("unreachable")
+								}
+								result306 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value305 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result306 = append(result306, value305)
+								}
+
+								result308 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value307 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result308 = append(result308, value307)
+								}
+
+								var option310 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option310 = witTypes.None[string]()
+								case 1:
+									value309 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option310 = witTypes.Some[string](value309)
+								default:
+									panic("unreachable")
+								}
+								var option313 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option313 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant312 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant312 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant312 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant312 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value311 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant312 = golem_core_types.MakeRoleOther(value311)
+
+									default:
+										panic("unreachable")
+									}
+
+									option313 = witTypes.Some[golem_core_types.Role](variant312)
+								default:
+									panic("unreachable")
+								}
+
+								result314 = append(result314, golem_core_types.NamedFieldType{value302, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option304, result306, result308, option310, option313}})
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyRecordType(result314)
+
+						case 15:
+							result328 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value315 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option316 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option316 = witTypes.None[int32]()
+								case 1:
+
+									option316 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option318 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option318 = witTypes.None[string]()
+								case 1:
+									value317 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option318 = witTypes.Some[string](value317)
+								default:
+									panic("unreachable")
+								}
+								result320 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value319 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result320 = append(result320, value319)
+								}
+
+								result322 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value321 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result322 = append(result322, value321)
+								}
+
+								var option324 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option324 = witTypes.None[string]()
+								case 1:
+									value323 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option324 = witTypes.Some[string](value323)
+								default:
+									panic("unreachable")
+								}
+								var option327 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option327 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant326 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant326 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant326 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant326 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value325 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant326 = golem_core_types.MakeRoleOther(value325)
+
+									default:
+										panic("unreachable")
+									}
+
+									option327 = witTypes.Some[golem_core_types.Role](variant326)
+								default:
+									panic("unreachable")
+								}
+
+								result328 = append(result328, golem_core_types.VariantCaseType{value315, option316, golem_core_types.MetadataEnvelope{option318, result320, result322, option324, option327}})
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyVariantType(result328)
+
+						case 16:
+							result330 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value329 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result330 = append(result330, value329)
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyEnumType(result330)
+
+						case 17:
+							result332 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value331 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result332 = append(result332, value331)
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyFlagsType(result332)
+
+						case 18:
+							result333 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result333 = append(result333, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyTupleType(result333)
+
+						case 19:
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option334 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option334 = witTypes.None[int32]()
+							case 1:
+
+								option334 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option335 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option335 = witTypes.None[int32]()
+							case 1:
+
+								option335 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option334, option335})
+
+						case 24:
+							var option338 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option338 = witTypes.None[[]string]()
+							case 1:
+								result337 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value336 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result337 = append(result337, value336)
+								}
+
+								option338 = witTypes.Some[[]string](result337)
+							default:
+								panic("unreachable")
+							}
+							var option339 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option339 = witTypes.None[uint32]()
+							case 1:
+
+								option339 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option340 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option340 = witTypes.None[uint32]()
+							case 1:
+
+								option340 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option342 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option342 = witTypes.None[string]()
+							case 1:
+								value341 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option342 = witTypes.Some[string](value341)
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option338, option339, option340, option342})
+
+						case 25:
+							var option345 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option345 = witTypes.None[[]string]()
+							case 1:
+								result344 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value343 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result344 = append(result344, value343)
+								}
+
+								option345 = witTypes.Some[[]string](result344)
+							default:
+								panic("unreachable")
+							}
+							var option346 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option346 = witTypes.None[uint32]()
+							case 1:
+
+								option346 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option347 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option347 = witTypes.None[uint32]()
+							case 1:
+
+								option347 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option345, option346, option347})
+
+						case 26:
+							var option350 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option350 = witTypes.None[[]string]()
+							case 1:
+								result349 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value348 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result349 = append(result349, value348)
+								}
+
+								option350 = witTypes.Some[[]string](result349)
+							default:
+								panic("unreachable")
+							}
+							var option353 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option353 = witTypes.None[[]string]()
+							case 1:
+								result352 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value351 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result352 = append(result352, value351)
+								}
+
+								option353 = witTypes.Some[[]string](result352)
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option350, option353})
+
+						case 27:
+							var option356 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option356 = witTypes.None[[]string]()
+							case 1:
+								result355 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value354 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result355 = append(result355, value354)
+								}
+
+								option356 = witTypes.Some[[]string](result355)
+							default:
+								panic("unreachable")
+							}
+							var option359 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option359 = witTypes.None[[]string]()
+							case 1:
+								result358 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value357 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result358 = append(result358, value357)
+								}
+
+								option359 = witTypes.Some[[]string](result358)
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option356, option359})
+
+						case 28:
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value360 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result362 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value361 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result362 = append(result362, value361)
+							}
+
+							var option364 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option364 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value363 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option364 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value363})
+							default:
+								panic("unreachable")
+							}
+							var option366 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option366 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value365 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option366 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value365})
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value360, result362, option364, option366})
+
+						case 31:
+							result388 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value367 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant376 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value368 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant376 = golem_core_types.MakeDiscriminatorRulePrefix(value368)
+
+								case 1:
+									value369 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant376 = golem_core_types.MakeDiscriminatorRuleSuffix(value369)
+
+								case 2:
+									value370 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant376 = golem_core_types.MakeDiscriminatorRuleContains(value370)
+
+								case 3:
+									value371 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant376 = golem_core_types.MakeDiscriminatorRuleRegex(value371)
+
+								case 4:
+									value372 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option374 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option374 = witTypes.None[string]()
+									case 1:
+										value373 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option374 = witTypes.Some[string](value373)
+									default:
+										panic("unreachable")
+									}
+
+									variant376 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value372, option374})
+
+								case 5:
+									value375 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant376 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value375)
+
+								default:
+									panic("unreachable")
+								}
+								var option378 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option378 = witTypes.None[string]()
+								case 1:
+									value377 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option378 = witTypes.Some[string](value377)
+								default:
+									panic("unreachable")
+								}
+								result380 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value379 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result380 = append(result380, value379)
+								}
+
+								result382 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value381 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result382 = append(result382, value381)
+								}
+
+								var option384 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option384 = witTypes.None[string]()
+								case 1:
+									value383 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option384 = witTypes.Some[string](value383)
+								default:
+									panic("unreachable")
+								}
+								var option387 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option387 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant386 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant386 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant386 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant386 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value385 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant386 = golem_core_types.MakeRoleOther(value385)
+
+									default:
+										panic("unreachable")
+									}
+
+									option387 = witTypes.Some[golem_core_types.Role](variant386)
+								default:
+									panic("unreachable")
+								}
+
+								result388 = append(result388, golem_core_types.UnionBranch{value367, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant376, golem_core_types.MetadataEnvelope{option378, result380, result382, option384, option387}})
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result388})
+
+						case 32:
+							var option390 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option390 = witTypes.None[string]()
+							case 1:
+								value389 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option390 = witTypes.Some[string](value389)
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option390})
+
+						case 33:
+							var option392 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option392 = witTypes.None[string]()
+							case 1:
+								value391 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option392 = witTypes.Some[string](value391)
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option392})
+
+						case 34:
+							var option393 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option393 = witTypes.None[int32]()
+							case 1:
+
+								option393 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyFutureType(option393)
+
+						case 35:
+							var option394 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option394 = witTypes.None[int32]()
+							case 1:
+
+								option394 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant395 = golem_core_types.MakeSchemaTypeBodyStreamType(option394)
+
+						default:
+							panic("unreachable")
+						}
+						var option397 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option397 = witTypes.None[string]()
+						case 1:
+							value396 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option397 = witTypes.Some[string](value396)
+						default:
+							panic("unreachable")
+						}
+						result399 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value398 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result399 = append(result399, value398)
+						}
+
+						result401 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value400 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result401 = append(result401, value400)
+						}
+
+						var option403 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option403 = witTypes.None[string]()
+						case 1:
+							value402 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option403 = witTypes.Some[string](value402)
+						default:
+							panic("unreachable")
+						}
+						var option406 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option406 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant405 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant405 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant405 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant405 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value404 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant405 = golem_core_types.MakeRoleOther(value404)
+
+							default:
+								panic("unreachable")
+							}
+
+							option406 = witTypes.Some[golem_core_types.Role](variant405)
+						default:
+							panic("unreachable")
+						}
+
+						result407 = append(result407, golem_core_types.SchemaTypeNode{variant395, golem_core_types.MetadataEnvelope{option397, result399, result401, option403, option406}})
+					}
+
+					result411 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))), index*(6*4))
+						value408 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option410 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option410 = witTypes.None[string]()
+						case 1:
+							value409 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option410 = witTypes.Some[string](value409)
+						default:
+							panic("unreachable")
+						}
+
+						result411 = append(result411, golem_core_types.SchemaTypeDef{value408, option410, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result435 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))), index*(16+4*4))
+						var variant434 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value412 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant434 = golem_core_types.MakeSchemaValueNodeStringValue(value412)
+
+						case 13:
+							result413 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result413 = append(result413, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant434 = golem_core_types.MakeSchemaValueNodeRecordValue(result413)
+
+						case 14:
+							var option414 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option414 = witTypes.None[int32]()
+							case 1:
+
+								option414 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant434 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option414})
+
+						case 15:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result415 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result415 = append(result415, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant434 = golem_core_types.MakeSchemaValueNodeFlagsValue(result415)
+
+						case 17:
+							result416 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result416 = append(result416, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant434 = golem_core_types.MakeSchemaValueNodeTupleValue(result416)
+
+						case 18:
+							result417 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result417 = append(result417, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant434 = golem_core_types.MakeSchemaValueNodeListValue(result417)
+
+						case 19:
+							result418 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result418 = append(result418, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant434 = golem_core_types.MakeSchemaValueNodeFixedListValue(result418)
+
+						case 20:
+							result419 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result419 = append(result419, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant434 = golem_core_types.MakeSchemaValueNodeMapValue(result419)
+
+						case 21:
+							var option420 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option420 = witTypes.None[int32]()
+							case 1:
+
+								option420 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant434 = golem_core_types.MakeSchemaValueNodeOptionValue(option420)
+
+						case 22:
+							var variant423 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option421 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option421 = witTypes.None[int32]()
+								case 1:
+
+									option421 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant423 = golem_core_types.MakeResultValuePayloadOkValue(option421)
+
+							case 1:
+								var option422 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option422 = witTypes.None[int32]()
+								case 1:
+
+									option422 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant423 = golem_core_types.MakeResultValuePayloadErrValue(option422)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant434 = golem_core_types.MakeSchemaValueNodeResultValue(variant423)
+
+						case 23:
+							value424 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option426 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option426 = witTypes.None[string]()
+							case 1:
+								value425 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option426 = witTypes.Some[string](value425)
+							default:
+								panic("unreachable")
+							}
+
+							variant434 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value424, option426})
+
+						case 24:
+							value427 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option429 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option429 = witTypes.None[string]()
+							case 1:
+								value428 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option429 = witTypes.Some[string](value428)
+							default:
+								panic("unreachable")
+							}
+
+							variant434 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value427, option429})
+
+						case 25:
+							value430 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant434 = golem_core_types.MakeSchemaValueNodePathValue(value430)
+
+						case 26:
+							value431 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant434 = golem_core_types.MakeSchemaValueNodeUrlValue(value431)
+
+						case 27:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value432 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant434 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value432})
+
+						case 30:
+							value433 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant434 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value433, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant434 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result435 = append(result435, variant434)
+					}
+
+					result436 = append(result436, LocalAgentConfigEntry{result232, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result407, result411, *(*int32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))}, golem_core_types.SchemaValueTree{result435, *(*int32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))}}})
+				}
+
+				var option437 witTypes.Option[golem_core_types.Uuid]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (128 + 10*4)))) {
+				case 0:
+
+					option437 = witTypes.None[golem_core_types.Uuid]()
+				case 1:
+
+					option437 = witTypes.Some[golem_core_types.Uuid](golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (136 + 10*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (144 + 10*4))))})
+				default:
+					panic("unreachable")
+				}
+
+				variant2693 = MakePublicOplogEntryCreate(CreateParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}}, value}, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4)))), result223, golem_core_types.AccountId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (56 + 4*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 4*4))))}}, golem_api_host.EnvironmentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (72 + 4*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (80 + 4*4))))}}, option, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (112 + 6*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (120 + 6*4)))), result230, result436, option437, golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (152 + 10*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (160 + 10*4))))}})
+
+			case 1:
+				var option438 witTypes.Option[uint64]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+				case 0:
+
+					option438 = witTypes.None[uint64]()
+				case 1:
+
+					option438 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+				default:
+					panic("unreachable")
+				}
+				value439 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+				var option644 witTypes.Option[golem_core_types.TypedSchemaValue]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))) {
+				case 0:
+
+					option644 = witTypes.None[golem_core_types.TypedSchemaValue]()
+				case 1:
+					result615 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))))), index*(56+22*4))
+						var variant603 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option446 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option446 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option441 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option441 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant440 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant440 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant440 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant440 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option441 = witTypes.Some[golem_core_types.NumericBound](variant440)
+								default:
+									panic("unreachable")
+								}
+								var option443 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option443 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant442 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant442 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant442 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant442 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option443 = witTypes.Some[golem_core_types.NumericBound](variant442)
+								default:
+									panic("unreachable")
+								}
+								var option445 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option445 = witTypes.None[string]()
+								case 1:
+									value444 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option445 = witTypes.Some[string](value444)
+								default:
+									panic("unreachable")
+								}
+
+								option446 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option441, option443, option445})
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyS8Type(option446)
+
+						case 3:
+							var option453 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option453 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option448 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option448 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant447 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant447 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant447 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant447 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option448 = witTypes.Some[golem_core_types.NumericBound](variant447)
+								default:
+									panic("unreachable")
+								}
+								var option450 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option450 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant449 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant449 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant449 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant449 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option450 = witTypes.Some[golem_core_types.NumericBound](variant449)
+								default:
+									panic("unreachable")
+								}
+								var option452 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option452 = witTypes.None[string]()
+								case 1:
+									value451 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option452 = witTypes.Some[string](value451)
+								default:
+									panic("unreachable")
+								}
+
+								option453 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option448, option450, option452})
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyS16Type(option453)
+
+						case 4:
+							var option460 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option460 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option455 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option455 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant454 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant454 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant454 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant454 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option455 = witTypes.Some[golem_core_types.NumericBound](variant454)
+								default:
+									panic("unreachable")
+								}
+								var option457 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option457 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant456 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant456 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant456 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant456 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option457 = witTypes.Some[golem_core_types.NumericBound](variant456)
+								default:
+									panic("unreachable")
+								}
+								var option459 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option459 = witTypes.None[string]()
+								case 1:
+									value458 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option459 = witTypes.Some[string](value458)
+								default:
+									panic("unreachable")
+								}
+
+								option460 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option455, option457, option459})
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyS32Type(option460)
+
+						case 5:
+							var option467 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option467 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option462 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option462 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant461 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant461 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant461 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant461 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option462 = witTypes.Some[golem_core_types.NumericBound](variant461)
+								default:
+									panic("unreachable")
+								}
+								var option464 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option464 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant463 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant463 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant463 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant463 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option464 = witTypes.Some[golem_core_types.NumericBound](variant463)
+								default:
+									panic("unreachable")
+								}
+								var option466 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option466 = witTypes.None[string]()
+								case 1:
+									value465 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option466 = witTypes.Some[string](value465)
+								default:
+									panic("unreachable")
+								}
+
+								option467 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option462, option464, option466})
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyS64Type(option467)
+
+						case 6:
+							var option474 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option474 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option469 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option469 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant468 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant468 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant468 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant468 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option469 = witTypes.Some[golem_core_types.NumericBound](variant468)
+								default:
+									panic("unreachable")
+								}
+								var option471 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option471 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant470 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant470 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant470 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant470 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option471 = witTypes.Some[golem_core_types.NumericBound](variant470)
+								default:
+									panic("unreachable")
+								}
+								var option473 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option473 = witTypes.None[string]()
+								case 1:
+									value472 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option473 = witTypes.Some[string](value472)
+								default:
+									panic("unreachable")
+								}
+
+								option474 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option469, option471, option473})
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyU8Type(option474)
+
+						case 7:
+							var option481 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option481 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option476 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option476 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant475 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant475 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant475 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant475 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option476 = witTypes.Some[golem_core_types.NumericBound](variant475)
+								default:
+									panic("unreachable")
+								}
+								var option478 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option478 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant477 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant477 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant477 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant477 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option478 = witTypes.Some[golem_core_types.NumericBound](variant477)
+								default:
+									panic("unreachable")
+								}
+								var option480 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option480 = witTypes.None[string]()
+								case 1:
+									value479 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option480 = witTypes.Some[string](value479)
+								default:
+									panic("unreachable")
+								}
+
+								option481 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option476, option478, option480})
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyU16Type(option481)
+
+						case 8:
+							var option488 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option488 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option483 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option483 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant482 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant482 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant482 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant482 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option483 = witTypes.Some[golem_core_types.NumericBound](variant482)
+								default:
+									panic("unreachable")
+								}
+								var option485 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option485 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant484 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant484 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant484 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant484 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option485 = witTypes.Some[golem_core_types.NumericBound](variant484)
+								default:
+									panic("unreachable")
+								}
+								var option487 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option487 = witTypes.None[string]()
+								case 1:
+									value486 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option487 = witTypes.Some[string](value486)
+								default:
+									panic("unreachable")
+								}
+
+								option488 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option483, option485, option487})
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyU32Type(option488)
+
+						case 9:
+							var option495 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option495 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option490 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option490 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant489 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant489 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant489 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant489 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option490 = witTypes.Some[golem_core_types.NumericBound](variant489)
+								default:
+									panic("unreachable")
+								}
+								var option492 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option492 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant491 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant491 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant491 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant491 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option492 = witTypes.Some[golem_core_types.NumericBound](variant491)
+								default:
+									panic("unreachable")
+								}
+								var option494 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option494 = witTypes.None[string]()
+								case 1:
+									value493 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option494 = witTypes.Some[string](value493)
+								default:
+									panic("unreachable")
+								}
+
+								option495 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option490, option492, option494})
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyU64Type(option495)
+
+						case 10:
+							var option502 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option502 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option497 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option497 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant496 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant496 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant496 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant496 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option497 = witTypes.Some[golem_core_types.NumericBound](variant496)
+								default:
+									panic("unreachable")
+								}
+								var option499 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option499 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant498 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant498 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant498 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant498 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option499 = witTypes.Some[golem_core_types.NumericBound](variant498)
+								default:
+									panic("unreachable")
+								}
+								var option501 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option501 = witTypes.None[string]()
+								case 1:
+									value500 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option501 = witTypes.Some[string](value500)
+								default:
+									panic("unreachable")
+								}
+
+								option502 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option497, option499, option501})
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyF32Type(option502)
+
+						case 11:
+							var option509 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option509 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option504 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option504 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant503 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant503 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant503 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant503 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option504 = witTypes.Some[golem_core_types.NumericBound](variant503)
+								default:
+									panic("unreachable")
+								}
+								var option506 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option506 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant505 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant505 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant505 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant505 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option506 = witTypes.Some[golem_core_types.NumericBound](variant505)
+								default:
+									panic("unreachable")
+								}
+								var option508 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option508 = witTypes.None[string]()
+								case 1:
+									value507 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option508 = witTypes.Some[string](value507)
+								default:
+									panic("unreachable")
+								}
+
+								option509 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option504, option506, option508})
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyF64Type(option509)
+
+						case 12:
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result522 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value510 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option512 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option512 = witTypes.None[string]()
+								case 1:
+									value511 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option512 = witTypes.Some[string](value511)
+								default:
+									panic("unreachable")
+								}
+								result514 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value513 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result514 = append(result514, value513)
+								}
+
+								result516 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value515 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result516 = append(result516, value515)
+								}
+
+								var option518 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option518 = witTypes.None[string]()
+								case 1:
+									value517 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option518 = witTypes.Some[string](value517)
+								default:
+									panic("unreachable")
+								}
+								var option521 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option521 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant520 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant520 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant520 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant520 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value519 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant520 = golem_core_types.MakeRoleOther(value519)
+
+									default:
+										panic("unreachable")
+									}
+
+									option521 = witTypes.Some[golem_core_types.Role](variant520)
+								default:
+									panic("unreachable")
+								}
+
+								result522 = append(result522, golem_core_types.NamedFieldType{value510, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option512, result514, result516, option518, option521}})
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyRecordType(result522)
+
+						case 15:
+							result536 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value523 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option524 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option524 = witTypes.None[int32]()
+								case 1:
+
+									option524 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option526 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option526 = witTypes.None[string]()
+								case 1:
+									value525 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option526 = witTypes.Some[string](value525)
+								default:
+									panic("unreachable")
+								}
+								result528 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value527 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result528 = append(result528, value527)
+								}
+
+								result530 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value529 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result530 = append(result530, value529)
+								}
+
+								var option532 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option532 = witTypes.None[string]()
+								case 1:
+									value531 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option532 = witTypes.Some[string](value531)
+								default:
+									panic("unreachable")
+								}
+								var option535 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option535 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant534 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant534 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant534 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant534 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value533 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant534 = golem_core_types.MakeRoleOther(value533)
+
+									default:
+										panic("unreachable")
+									}
+
+									option535 = witTypes.Some[golem_core_types.Role](variant534)
+								default:
+									panic("unreachable")
+								}
+
+								result536 = append(result536, golem_core_types.VariantCaseType{value523, option524, golem_core_types.MetadataEnvelope{option526, result528, result530, option532, option535}})
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyVariantType(result536)
+
+						case 16:
+							result538 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value537 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result538 = append(result538, value537)
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyEnumType(result538)
+
+						case 17:
+							result540 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value539 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result540 = append(result540, value539)
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyFlagsType(result540)
+
+						case 18:
+							result541 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result541 = append(result541, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyTupleType(result541)
+
+						case 19:
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option542 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option542 = witTypes.None[int32]()
+							case 1:
+
+								option542 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option543 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option543 = witTypes.None[int32]()
+							case 1:
+
+								option543 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option542, option543})
+
+						case 24:
+							var option546 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option546 = witTypes.None[[]string]()
+							case 1:
+								result545 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value544 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result545 = append(result545, value544)
+								}
+
+								option546 = witTypes.Some[[]string](result545)
+							default:
+								panic("unreachable")
+							}
+							var option547 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option547 = witTypes.None[uint32]()
+							case 1:
+
+								option547 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option548 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option548 = witTypes.None[uint32]()
+							case 1:
+
+								option548 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option550 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option550 = witTypes.None[string]()
+							case 1:
+								value549 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option550 = witTypes.Some[string](value549)
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option546, option547, option548, option550})
+
+						case 25:
+							var option553 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option553 = witTypes.None[[]string]()
+							case 1:
+								result552 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value551 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result552 = append(result552, value551)
+								}
+
+								option553 = witTypes.Some[[]string](result552)
+							default:
+								panic("unreachable")
+							}
+							var option554 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option554 = witTypes.None[uint32]()
+							case 1:
+
+								option554 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option555 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option555 = witTypes.None[uint32]()
+							case 1:
+
+								option555 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option553, option554, option555})
+
+						case 26:
+							var option558 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option558 = witTypes.None[[]string]()
+							case 1:
+								result557 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value556 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result557 = append(result557, value556)
+								}
+
+								option558 = witTypes.Some[[]string](result557)
+							default:
+								panic("unreachable")
+							}
+							var option561 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option561 = witTypes.None[[]string]()
+							case 1:
+								result560 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value559 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result560 = append(result560, value559)
+								}
+
+								option561 = witTypes.Some[[]string](result560)
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option558, option561})
+
+						case 27:
+							var option564 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option564 = witTypes.None[[]string]()
+							case 1:
+								result563 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value562 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result563 = append(result563, value562)
+								}
+
+								option564 = witTypes.Some[[]string](result563)
+							default:
+								panic("unreachable")
+							}
+							var option567 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option567 = witTypes.None[[]string]()
+							case 1:
+								result566 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value565 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result566 = append(result566, value565)
+								}
+
+								option567 = witTypes.Some[[]string](result566)
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option564, option567})
+
+						case 28:
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value568 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result570 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value569 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result570 = append(result570, value569)
+							}
+
+							var option572 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option572 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value571 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option572 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value571})
+							default:
+								panic("unreachable")
+							}
+							var option574 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option574 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value573 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option574 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value573})
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value568, result570, option572, option574})
+
+						case 31:
+							result596 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value575 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant584 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value576 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant584 = golem_core_types.MakeDiscriminatorRulePrefix(value576)
+
+								case 1:
+									value577 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant584 = golem_core_types.MakeDiscriminatorRuleSuffix(value577)
+
+								case 2:
+									value578 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant584 = golem_core_types.MakeDiscriminatorRuleContains(value578)
+
+								case 3:
+									value579 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant584 = golem_core_types.MakeDiscriminatorRuleRegex(value579)
+
+								case 4:
+									value580 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option582 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option582 = witTypes.None[string]()
+									case 1:
+										value581 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option582 = witTypes.Some[string](value581)
+									default:
+										panic("unreachable")
+									}
+
+									variant584 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value580, option582})
+
+								case 5:
+									value583 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant584 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value583)
+
+								default:
+									panic("unreachable")
+								}
+								var option586 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option586 = witTypes.None[string]()
+								case 1:
+									value585 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option586 = witTypes.Some[string](value585)
+								default:
+									panic("unreachable")
+								}
+								result588 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value587 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result588 = append(result588, value587)
+								}
+
+								result590 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value589 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result590 = append(result590, value589)
+								}
+
+								var option592 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option592 = witTypes.None[string]()
+								case 1:
+									value591 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option592 = witTypes.Some[string](value591)
+								default:
+									panic("unreachable")
+								}
+								var option595 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option595 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant594 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant594 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant594 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant594 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value593 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant594 = golem_core_types.MakeRoleOther(value593)
+
+									default:
+										panic("unreachable")
+									}
+
+									option595 = witTypes.Some[golem_core_types.Role](variant594)
+								default:
+									panic("unreachable")
+								}
+
+								result596 = append(result596, golem_core_types.UnionBranch{value575, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant584, golem_core_types.MetadataEnvelope{option586, result588, result590, option592, option595}})
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result596})
+
+						case 32:
+							var option598 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option598 = witTypes.None[string]()
+							case 1:
+								value597 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option598 = witTypes.Some[string](value597)
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option598})
+
+						case 33:
+							var option600 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option600 = witTypes.None[string]()
+							case 1:
+								value599 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option600 = witTypes.Some[string](value599)
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option600})
+
+						case 34:
+							var option601 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option601 = witTypes.None[int32]()
+							case 1:
+
+								option601 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyFutureType(option601)
+
+						case 35:
+							var option602 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option602 = witTypes.None[int32]()
+							case 1:
+
+								option602 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant603 = golem_core_types.MakeSchemaTypeBodyStreamType(option602)
+
+						default:
+							panic("unreachable")
+						}
+						var option605 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option605 = witTypes.None[string]()
+						case 1:
+							value604 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option605 = witTypes.Some[string](value604)
+						default:
+							panic("unreachable")
+						}
+						result607 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value606 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result607 = append(result607, value606)
+						}
+
+						result609 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value608 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result609 = append(result609, value608)
+						}
+
+						var option611 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option611 = witTypes.None[string]()
+						case 1:
+							value610 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option611 = witTypes.Some[string](value610)
+						default:
+							panic("unreachable")
+						}
+						var option614 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option614 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant613 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant613 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant613 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant613 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value612 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant613 = golem_core_types.MakeRoleOther(value612)
+
+							default:
+								panic("unreachable")
+							}
+
+							option614 = witTypes.Some[golem_core_types.Role](variant613)
+						default:
+							panic("unreachable")
+						}
+
+						result615 = append(result615, golem_core_types.SchemaTypeNode{variant603, golem_core_types.MetadataEnvelope{option605, result607, result609, option611, option614}})
+					}
+
+					result619 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4))))), index*(6*4))
+						value616 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option618 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option618 = witTypes.None[string]()
+						case 1:
+							value617 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option618 = witTypes.Some[string](value617)
+						default:
+							panic("unreachable")
+						}
+
+						result619 = append(result619, golem_core_types.SchemaTypeDef{value616, option618, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result643 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 9*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 9*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4))))), index*(16+4*4))
+						var variant642 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value620 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant642 = golem_core_types.MakeSchemaValueNodeStringValue(value620)
+
+						case 13:
+							result621 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result621 = append(result621, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant642 = golem_core_types.MakeSchemaValueNodeRecordValue(result621)
+
+						case 14:
+							var option622 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option622 = witTypes.None[int32]()
+							case 1:
+
+								option622 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant642 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option622})
+
+						case 15:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result623 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result623 = append(result623, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant642 = golem_core_types.MakeSchemaValueNodeFlagsValue(result623)
+
+						case 17:
+							result624 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result624 = append(result624, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant642 = golem_core_types.MakeSchemaValueNodeTupleValue(result624)
+
+						case 18:
+							result625 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result625 = append(result625, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant642 = golem_core_types.MakeSchemaValueNodeListValue(result625)
+
+						case 19:
+							result626 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result626 = append(result626, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant642 = golem_core_types.MakeSchemaValueNodeFixedListValue(result626)
+
+						case 20:
+							result627 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result627 = append(result627, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant642 = golem_core_types.MakeSchemaValueNodeMapValue(result627)
+
+						case 21:
+							var option628 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option628 = witTypes.None[int32]()
+							case 1:
+
+								option628 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant642 = golem_core_types.MakeSchemaValueNodeOptionValue(option628)
+
+						case 22:
+							var variant631 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option629 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option629 = witTypes.None[int32]()
+								case 1:
+
+									option629 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant631 = golem_core_types.MakeResultValuePayloadOkValue(option629)
+
+							case 1:
+								var option630 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option630 = witTypes.None[int32]()
+								case 1:
+
+									option630 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant631 = golem_core_types.MakeResultValuePayloadErrValue(option630)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant642 = golem_core_types.MakeSchemaValueNodeResultValue(variant631)
+
+						case 23:
+							value632 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option634 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option634 = witTypes.None[string]()
+							case 1:
+								value633 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option634 = witTypes.Some[string](value633)
+							default:
+								panic("unreachable")
+							}
+
+							variant642 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value632, option634})
+
+						case 24:
+							value635 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option637 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option637 = witTypes.None[string]()
+							case 1:
+								value636 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option637 = witTypes.Some[string](value636)
+							default:
+								panic("unreachable")
+							}
+
+							variant642 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value635, option637})
+
+						case 25:
+							value638 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant642 = golem_core_types.MakeSchemaValueNodePathValue(value638)
+
+						case 26:
+							value639 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant642 = golem_core_types.MakeSchemaValueNodeUrlValue(value639)
+
+						case 27:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value640 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant642 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value640})
+
+						case 30:
+							value641 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant642 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value641, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant642 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result643 = append(result643, variant642)
+					}
+
+					option644 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result615, result619, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 7*4)))}, golem_core_types.SchemaValueTree{result643, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 10*4)))}})
+				default:
+					panic("unreachable")
+				}
+				var variant647 WrappedFunctionType
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 10*4)))) {
+				case 0:
+
+					variant647 = MakeWrappedFunctionTypeReadLocal()
+
+				case 1:
+
+					variant647 = MakeWrappedFunctionTypeWriteLocal()
+
+				case 2:
+
+					variant647 = MakeWrappedFunctionTypeReadRemote()
+
+				case 3:
+
+					variant647 = MakeWrappedFunctionTypeWriteRemote()
+
+				case 4:
+					var option645 witTypes.Option[uint64]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) {
+					case 0:
+
+						option645 = witTypes.None[uint64]()
+					case 1:
+
+						option645 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 10*4)))))
+					default:
+						panic("unreachable")
+					}
+
+					variant647 = MakeWrappedFunctionTypeWriteRemoteBatched(option645)
+
+				case 5:
+					var option646 witTypes.Option[uint64]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) {
+					case 0:
+
+						option646 = witTypes.None[uint64]()
+					case 1:
+
+						option646 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 10*4)))))
+					default:
+						panic("unreachable")
+					}
+
+					variant647 = MakeWrappedFunctionTypeWriteRemoteTransaction(option646)
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2693 = MakePublicOplogEntryStart(StartParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, option438, value439, option644, variant647})
+
+			case 2:
+				var option852 witTypes.Option[golem_core_types.TypedSchemaValue]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+				case 0:
+
+					option852 = witTypes.None[golem_core_types.TypedSchemaValue]()
+				case 1:
+					result823 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))), index*(56+22*4))
+						var variant811 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option654 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option654 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option649 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option649 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant648 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant648 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant648 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant648 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option649 = witTypes.Some[golem_core_types.NumericBound](variant648)
+								default:
+									panic("unreachable")
+								}
+								var option651 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option651 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant650 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant650 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant650 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant650 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option651 = witTypes.Some[golem_core_types.NumericBound](variant650)
+								default:
+									panic("unreachable")
+								}
+								var option653 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option653 = witTypes.None[string]()
+								case 1:
+									value652 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option653 = witTypes.Some[string](value652)
+								default:
+									panic("unreachable")
+								}
+
+								option654 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option649, option651, option653})
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyS8Type(option654)
+
+						case 3:
+							var option661 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option661 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option656 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option656 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant655 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant655 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant655 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant655 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option656 = witTypes.Some[golem_core_types.NumericBound](variant655)
+								default:
+									panic("unreachable")
+								}
+								var option658 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option658 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant657 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant657 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant657 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant657 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option658 = witTypes.Some[golem_core_types.NumericBound](variant657)
+								default:
+									panic("unreachable")
+								}
+								var option660 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option660 = witTypes.None[string]()
+								case 1:
+									value659 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option660 = witTypes.Some[string](value659)
+								default:
+									panic("unreachable")
+								}
+
+								option661 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option656, option658, option660})
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyS16Type(option661)
+
+						case 4:
+							var option668 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option668 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option663 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option663 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant662 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant662 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant662 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant662 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option663 = witTypes.Some[golem_core_types.NumericBound](variant662)
+								default:
+									panic("unreachable")
+								}
+								var option665 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option665 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant664 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant664 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant664 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant664 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option665 = witTypes.Some[golem_core_types.NumericBound](variant664)
+								default:
+									panic("unreachable")
+								}
+								var option667 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option667 = witTypes.None[string]()
+								case 1:
+									value666 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option667 = witTypes.Some[string](value666)
+								default:
+									panic("unreachable")
+								}
+
+								option668 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option663, option665, option667})
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyS32Type(option668)
+
+						case 5:
+							var option675 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option675 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option670 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option670 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant669 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant669 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant669 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant669 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option670 = witTypes.Some[golem_core_types.NumericBound](variant669)
+								default:
+									panic("unreachable")
+								}
+								var option672 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option672 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant671 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant671 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant671 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant671 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option672 = witTypes.Some[golem_core_types.NumericBound](variant671)
+								default:
+									panic("unreachable")
+								}
+								var option674 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option674 = witTypes.None[string]()
+								case 1:
+									value673 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option674 = witTypes.Some[string](value673)
+								default:
+									panic("unreachable")
+								}
+
+								option675 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option670, option672, option674})
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyS64Type(option675)
+
+						case 6:
+							var option682 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option682 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option677 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option677 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant676 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant676 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant676 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant676 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option677 = witTypes.Some[golem_core_types.NumericBound](variant676)
+								default:
+									panic("unreachable")
+								}
+								var option679 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option679 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant678 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant678 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant678 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant678 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option679 = witTypes.Some[golem_core_types.NumericBound](variant678)
+								default:
+									panic("unreachable")
+								}
+								var option681 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option681 = witTypes.None[string]()
+								case 1:
+									value680 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option681 = witTypes.Some[string](value680)
+								default:
+									panic("unreachable")
+								}
+
+								option682 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option677, option679, option681})
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyU8Type(option682)
+
+						case 7:
+							var option689 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option689 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option684 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option684 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant683 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant683 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant683 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant683 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option684 = witTypes.Some[golem_core_types.NumericBound](variant683)
+								default:
+									panic("unreachable")
+								}
+								var option686 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option686 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant685 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant685 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant685 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant685 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option686 = witTypes.Some[golem_core_types.NumericBound](variant685)
+								default:
+									panic("unreachable")
+								}
+								var option688 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option688 = witTypes.None[string]()
+								case 1:
+									value687 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option688 = witTypes.Some[string](value687)
+								default:
+									panic("unreachable")
+								}
+
+								option689 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option684, option686, option688})
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyU16Type(option689)
+
+						case 8:
+							var option696 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option696 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option691 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option691 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant690 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant690 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant690 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant690 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option691 = witTypes.Some[golem_core_types.NumericBound](variant690)
+								default:
+									panic("unreachable")
+								}
+								var option693 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option693 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant692 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant692 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant692 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant692 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option693 = witTypes.Some[golem_core_types.NumericBound](variant692)
+								default:
+									panic("unreachable")
+								}
+								var option695 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option695 = witTypes.None[string]()
+								case 1:
+									value694 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option695 = witTypes.Some[string](value694)
+								default:
+									panic("unreachable")
+								}
+
+								option696 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option691, option693, option695})
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyU32Type(option696)
+
+						case 9:
+							var option703 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option703 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option698 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option698 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant697 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant697 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant697 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant697 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option698 = witTypes.Some[golem_core_types.NumericBound](variant697)
+								default:
+									panic("unreachable")
+								}
+								var option700 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option700 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant699 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant699 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant699 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant699 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option700 = witTypes.Some[golem_core_types.NumericBound](variant699)
+								default:
+									panic("unreachable")
+								}
+								var option702 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option702 = witTypes.None[string]()
+								case 1:
+									value701 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option702 = witTypes.Some[string](value701)
+								default:
+									panic("unreachable")
+								}
+
+								option703 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option698, option700, option702})
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyU64Type(option703)
+
+						case 10:
+							var option710 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option710 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option705 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option705 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant704 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant704 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant704 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant704 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option705 = witTypes.Some[golem_core_types.NumericBound](variant704)
+								default:
+									panic("unreachable")
+								}
+								var option707 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option707 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant706 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant706 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant706 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant706 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option707 = witTypes.Some[golem_core_types.NumericBound](variant706)
+								default:
+									panic("unreachable")
+								}
+								var option709 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option709 = witTypes.None[string]()
+								case 1:
+									value708 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option709 = witTypes.Some[string](value708)
+								default:
+									panic("unreachable")
+								}
+
+								option710 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option705, option707, option709})
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyF32Type(option710)
+
+						case 11:
+							var option717 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option717 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option712 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option712 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant711 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant711 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant711 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant711 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option712 = witTypes.Some[golem_core_types.NumericBound](variant711)
+								default:
+									panic("unreachable")
+								}
+								var option714 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option714 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant713 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant713 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant713 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant713 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option714 = witTypes.Some[golem_core_types.NumericBound](variant713)
+								default:
+									panic("unreachable")
+								}
+								var option716 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option716 = witTypes.None[string]()
+								case 1:
+									value715 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option716 = witTypes.Some[string](value715)
+								default:
+									panic("unreachable")
+								}
+
+								option717 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option712, option714, option716})
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyF64Type(option717)
+
+						case 12:
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result730 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value718 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option720 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option720 = witTypes.None[string]()
+								case 1:
+									value719 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option720 = witTypes.Some[string](value719)
+								default:
+									panic("unreachable")
+								}
+								result722 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value721 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result722 = append(result722, value721)
+								}
+
+								result724 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value723 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result724 = append(result724, value723)
+								}
+
+								var option726 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option726 = witTypes.None[string]()
+								case 1:
+									value725 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option726 = witTypes.Some[string](value725)
+								default:
+									panic("unreachable")
+								}
+								var option729 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option729 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant728 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant728 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant728 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant728 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value727 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant728 = golem_core_types.MakeRoleOther(value727)
+
+									default:
+										panic("unreachable")
+									}
+
+									option729 = witTypes.Some[golem_core_types.Role](variant728)
+								default:
+									panic("unreachable")
+								}
+
+								result730 = append(result730, golem_core_types.NamedFieldType{value718, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option720, result722, result724, option726, option729}})
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyRecordType(result730)
+
+						case 15:
+							result744 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value731 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option732 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option732 = witTypes.None[int32]()
+								case 1:
+
+									option732 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option734 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option734 = witTypes.None[string]()
+								case 1:
+									value733 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option734 = witTypes.Some[string](value733)
+								default:
+									panic("unreachable")
+								}
+								result736 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value735 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result736 = append(result736, value735)
+								}
+
+								result738 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value737 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result738 = append(result738, value737)
+								}
+
+								var option740 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option740 = witTypes.None[string]()
+								case 1:
+									value739 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option740 = witTypes.Some[string](value739)
+								default:
+									panic("unreachable")
+								}
+								var option743 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option743 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant742 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant742 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant742 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant742 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value741 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant742 = golem_core_types.MakeRoleOther(value741)
+
+									default:
+										panic("unreachable")
+									}
+
+									option743 = witTypes.Some[golem_core_types.Role](variant742)
+								default:
+									panic("unreachable")
+								}
+
+								result744 = append(result744, golem_core_types.VariantCaseType{value731, option732, golem_core_types.MetadataEnvelope{option734, result736, result738, option740, option743}})
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyVariantType(result744)
+
+						case 16:
+							result746 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value745 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result746 = append(result746, value745)
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyEnumType(result746)
+
+						case 17:
+							result748 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value747 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result748 = append(result748, value747)
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyFlagsType(result748)
+
+						case 18:
+							result749 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result749 = append(result749, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyTupleType(result749)
+
+						case 19:
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option750 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option750 = witTypes.None[int32]()
+							case 1:
+
+								option750 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option751 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option751 = witTypes.None[int32]()
+							case 1:
+
+								option751 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option750, option751})
+
+						case 24:
+							var option754 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option754 = witTypes.None[[]string]()
+							case 1:
+								result753 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value752 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result753 = append(result753, value752)
+								}
+
+								option754 = witTypes.Some[[]string](result753)
+							default:
+								panic("unreachable")
+							}
+							var option755 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option755 = witTypes.None[uint32]()
+							case 1:
+
+								option755 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option756 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option756 = witTypes.None[uint32]()
+							case 1:
+
+								option756 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option758 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option758 = witTypes.None[string]()
+							case 1:
+								value757 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option758 = witTypes.Some[string](value757)
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option754, option755, option756, option758})
+
+						case 25:
+							var option761 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option761 = witTypes.None[[]string]()
+							case 1:
+								result760 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value759 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result760 = append(result760, value759)
+								}
+
+								option761 = witTypes.Some[[]string](result760)
+							default:
+								panic("unreachable")
+							}
+							var option762 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option762 = witTypes.None[uint32]()
+							case 1:
+
+								option762 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option763 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option763 = witTypes.None[uint32]()
+							case 1:
+
+								option763 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option761, option762, option763})
+
+						case 26:
+							var option766 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option766 = witTypes.None[[]string]()
+							case 1:
+								result765 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value764 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result765 = append(result765, value764)
+								}
+
+								option766 = witTypes.Some[[]string](result765)
+							default:
+								panic("unreachable")
+							}
+							var option769 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option769 = witTypes.None[[]string]()
+							case 1:
+								result768 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value767 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result768 = append(result768, value767)
+								}
+
+								option769 = witTypes.Some[[]string](result768)
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option766, option769})
+
+						case 27:
+							var option772 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option772 = witTypes.None[[]string]()
+							case 1:
+								result771 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value770 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result771 = append(result771, value770)
+								}
+
+								option772 = witTypes.Some[[]string](result771)
+							default:
+								panic("unreachable")
+							}
+							var option775 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option775 = witTypes.None[[]string]()
+							case 1:
+								result774 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value773 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result774 = append(result774, value773)
+								}
+
+								option775 = witTypes.Some[[]string](result774)
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option772, option775})
+
+						case 28:
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value776 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result778 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value777 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result778 = append(result778, value777)
+							}
+
+							var option780 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option780 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value779 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option780 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value779})
+							default:
+								panic("unreachable")
+							}
+							var option782 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option782 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value781 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option782 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value781})
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value776, result778, option780, option782})
+
+						case 31:
+							result804 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value783 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant792 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value784 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant792 = golem_core_types.MakeDiscriminatorRulePrefix(value784)
+
+								case 1:
+									value785 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant792 = golem_core_types.MakeDiscriminatorRuleSuffix(value785)
+
+								case 2:
+									value786 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant792 = golem_core_types.MakeDiscriminatorRuleContains(value786)
+
+								case 3:
+									value787 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant792 = golem_core_types.MakeDiscriminatorRuleRegex(value787)
+
+								case 4:
+									value788 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option790 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option790 = witTypes.None[string]()
+									case 1:
+										value789 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option790 = witTypes.Some[string](value789)
+									default:
+										panic("unreachable")
+									}
+
+									variant792 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value788, option790})
+
+								case 5:
+									value791 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant792 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value791)
+
+								default:
+									panic("unreachable")
+								}
+								var option794 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option794 = witTypes.None[string]()
+								case 1:
+									value793 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option794 = witTypes.Some[string](value793)
+								default:
+									panic("unreachable")
+								}
+								result796 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value795 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result796 = append(result796, value795)
+								}
+
+								result798 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value797 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result798 = append(result798, value797)
+								}
+
+								var option800 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option800 = witTypes.None[string]()
+								case 1:
+									value799 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option800 = witTypes.Some[string](value799)
+								default:
+									panic("unreachable")
+								}
+								var option803 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option803 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant802 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant802 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant802 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant802 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value801 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant802 = golem_core_types.MakeRoleOther(value801)
+
+									default:
+										panic("unreachable")
+									}
+
+									option803 = witTypes.Some[golem_core_types.Role](variant802)
+								default:
+									panic("unreachable")
+								}
+
+								result804 = append(result804, golem_core_types.UnionBranch{value783, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant792, golem_core_types.MetadataEnvelope{option794, result796, result798, option800, option803}})
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result804})
+
+						case 32:
+							var option806 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option806 = witTypes.None[string]()
+							case 1:
+								value805 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option806 = witTypes.Some[string](value805)
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option806})
+
+						case 33:
+							var option808 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option808 = witTypes.None[string]()
+							case 1:
+								value807 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option808 = witTypes.Some[string](value807)
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option808})
+
+						case 34:
+							var option809 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option809 = witTypes.None[int32]()
+							case 1:
+
+								option809 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyFutureType(option809)
+
+						case 35:
+							var option810 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option810 = witTypes.None[int32]()
+							case 1:
+
+								option810 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant811 = golem_core_types.MakeSchemaTypeBodyStreamType(option810)
+
+						default:
+							panic("unreachable")
+						}
+						var option813 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option813 = witTypes.None[string]()
+						case 1:
+							value812 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option813 = witTypes.Some[string](value812)
+						default:
+							panic("unreachable")
+						}
+						result815 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value814 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result815 = append(result815, value814)
+						}
+
+						result817 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value816 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result817 = append(result817, value816)
+						}
+
+						var option819 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option819 = witTypes.None[string]()
+						case 1:
+							value818 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option819 = witTypes.Some[string](value818)
+						default:
+							panic("unreachable")
+						}
+						var option822 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option822 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant821 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant821 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant821 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant821 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value820 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant821 = golem_core_types.MakeRoleOther(value820)
+
+							default:
+								panic("unreachable")
+							}
+
+							option822 = witTypes.Some[golem_core_types.Role](variant821)
+						default:
+							panic("unreachable")
+						}
+
+						result823 = append(result823, golem_core_types.SchemaTypeNode{variant811, golem_core_types.MetadataEnvelope{option813, result815, result817, option819, option822}})
+					}
+
+					result827 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))), index*(6*4))
+						value824 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option826 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option826 = witTypes.None[string]()
+						case 1:
+							value825 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option826 = witTypes.Some[string](value825)
+						default:
+							panic("unreachable")
+						}
+
+						result827 = append(result827, golem_core_types.SchemaTypeDef{value824, option826, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result851 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))))), index*(16+4*4))
+						var variant850 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value828 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant850 = golem_core_types.MakeSchemaValueNodeStringValue(value828)
+
+						case 13:
+							result829 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result829 = append(result829, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant850 = golem_core_types.MakeSchemaValueNodeRecordValue(result829)
+
+						case 14:
+							var option830 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option830 = witTypes.None[int32]()
+							case 1:
+
+								option830 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant850 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option830})
+
+						case 15:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result831 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result831 = append(result831, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant850 = golem_core_types.MakeSchemaValueNodeFlagsValue(result831)
+
+						case 17:
+							result832 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result832 = append(result832, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant850 = golem_core_types.MakeSchemaValueNodeTupleValue(result832)
+
+						case 18:
+							result833 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result833 = append(result833, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant850 = golem_core_types.MakeSchemaValueNodeListValue(result833)
+
+						case 19:
+							result834 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result834 = append(result834, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant850 = golem_core_types.MakeSchemaValueNodeFixedListValue(result834)
+
+						case 20:
+							result835 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result835 = append(result835, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant850 = golem_core_types.MakeSchemaValueNodeMapValue(result835)
+
+						case 21:
+							var option836 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option836 = witTypes.None[int32]()
+							case 1:
+
+								option836 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant850 = golem_core_types.MakeSchemaValueNodeOptionValue(option836)
+
+						case 22:
+							var variant839 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option837 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option837 = witTypes.None[int32]()
+								case 1:
+
+									option837 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant839 = golem_core_types.MakeResultValuePayloadOkValue(option837)
+
+							case 1:
+								var option838 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option838 = witTypes.None[int32]()
+								case 1:
+
+									option838 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant839 = golem_core_types.MakeResultValuePayloadErrValue(option838)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant850 = golem_core_types.MakeSchemaValueNodeResultValue(variant839)
+
+						case 23:
+							value840 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option842 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option842 = witTypes.None[string]()
+							case 1:
+								value841 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option842 = witTypes.Some[string](value841)
+							default:
+								panic("unreachable")
+							}
+
+							variant850 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value840, option842})
+
+						case 24:
+							value843 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option845 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option845 = witTypes.None[string]()
+							case 1:
+								value844 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option845 = witTypes.Some[string](value844)
+							default:
+								panic("unreachable")
+							}
+
+							variant850 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value843, option845})
+
+						case 25:
+							value846 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant850 = golem_core_types.MakeSchemaValueNodePathValue(value846)
+
+						case 26:
+							value847 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant850 = golem_core_types.MakeSchemaValueNodeUrlValue(value847)
+
+						case 27:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value848 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant850 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value848})
+
+						case 30:
+							value849 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant850 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value849, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant850 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result851 = append(result851, variant850)
+					}
+
+					option852 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result823, result827, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result851, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}})
+				default:
+					panic("unreachable")
+				}
+
+				variant2693 = MakePublicOplogEntryEnd(EndParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), option852, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4)))) != 0)})
+
+			case 3:
+				var option1057 witTypes.Option[golem_core_types.TypedSchemaValue]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+				case 0:
+
+					option1057 = witTypes.None[golem_core_types.TypedSchemaValue]()
+				case 1:
+					result1028 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))), index*(56+22*4))
+						var variant1016 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option859 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option859 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option854 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option854 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant853 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant853 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant853 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant853 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option854 = witTypes.Some[golem_core_types.NumericBound](variant853)
+								default:
+									panic("unreachable")
+								}
+								var option856 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option856 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant855 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant855 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant855 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant855 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option856 = witTypes.Some[golem_core_types.NumericBound](variant855)
+								default:
+									panic("unreachable")
+								}
+								var option858 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option858 = witTypes.None[string]()
+								case 1:
+									value857 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option858 = witTypes.Some[string](value857)
+								default:
+									panic("unreachable")
+								}
+
+								option859 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option854, option856, option858})
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyS8Type(option859)
+
+						case 3:
+							var option866 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option866 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option861 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option861 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant860 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant860 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant860 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant860 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option861 = witTypes.Some[golem_core_types.NumericBound](variant860)
+								default:
+									panic("unreachable")
+								}
+								var option863 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option863 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant862 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant862 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant862 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant862 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option863 = witTypes.Some[golem_core_types.NumericBound](variant862)
+								default:
+									panic("unreachable")
+								}
+								var option865 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option865 = witTypes.None[string]()
+								case 1:
+									value864 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option865 = witTypes.Some[string](value864)
+								default:
+									panic("unreachable")
+								}
+
+								option866 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option861, option863, option865})
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyS16Type(option866)
+
+						case 4:
+							var option873 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option873 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option868 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option868 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant867 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant867 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant867 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant867 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option868 = witTypes.Some[golem_core_types.NumericBound](variant867)
+								default:
+									panic("unreachable")
+								}
+								var option870 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option870 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant869 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant869 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant869 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant869 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option870 = witTypes.Some[golem_core_types.NumericBound](variant869)
+								default:
+									panic("unreachable")
+								}
+								var option872 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option872 = witTypes.None[string]()
+								case 1:
+									value871 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option872 = witTypes.Some[string](value871)
+								default:
+									panic("unreachable")
+								}
+
+								option873 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option868, option870, option872})
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyS32Type(option873)
+
+						case 5:
+							var option880 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option880 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option875 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option875 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant874 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant874 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant874 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant874 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option875 = witTypes.Some[golem_core_types.NumericBound](variant874)
+								default:
+									panic("unreachable")
+								}
+								var option877 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option877 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant876 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant876 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant876 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant876 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option877 = witTypes.Some[golem_core_types.NumericBound](variant876)
+								default:
+									panic("unreachable")
+								}
+								var option879 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option879 = witTypes.None[string]()
+								case 1:
+									value878 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option879 = witTypes.Some[string](value878)
+								default:
+									panic("unreachable")
+								}
+
+								option880 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option875, option877, option879})
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyS64Type(option880)
+
+						case 6:
+							var option887 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option887 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option882 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option882 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant881 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant881 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant881 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant881 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option882 = witTypes.Some[golem_core_types.NumericBound](variant881)
+								default:
+									panic("unreachable")
+								}
+								var option884 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option884 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant883 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant883 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant883 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant883 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option884 = witTypes.Some[golem_core_types.NumericBound](variant883)
+								default:
+									panic("unreachable")
+								}
+								var option886 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option886 = witTypes.None[string]()
+								case 1:
+									value885 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option886 = witTypes.Some[string](value885)
+								default:
+									panic("unreachable")
+								}
+
+								option887 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option882, option884, option886})
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyU8Type(option887)
+
+						case 7:
+							var option894 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option894 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option889 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option889 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant888 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant888 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant888 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant888 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option889 = witTypes.Some[golem_core_types.NumericBound](variant888)
+								default:
+									panic("unreachable")
+								}
+								var option891 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option891 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant890 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant890 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant890 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant890 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option891 = witTypes.Some[golem_core_types.NumericBound](variant890)
+								default:
+									panic("unreachable")
+								}
+								var option893 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option893 = witTypes.None[string]()
+								case 1:
+									value892 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option893 = witTypes.Some[string](value892)
+								default:
+									panic("unreachable")
+								}
+
+								option894 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option889, option891, option893})
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyU16Type(option894)
+
+						case 8:
+							var option901 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option901 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option896 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option896 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant895 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant895 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant895 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant895 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option896 = witTypes.Some[golem_core_types.NumericBound](variant895)
+								default:
+									panic("unreachable")
+								}
+								var option898 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option898 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant897 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant897 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant897 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant897 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option898 = witTypes.Some[golem_core_types.NumericBound](variant897)
+								default:
+									panic("unreachable")
+								}
+								var option900 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option900 = witTypes.None[string]()
+								case 1:
+									value899 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option900 = witTypes.Some[string](value899)
+								default:
+									panic("unreachable")
+								}
+
+								option901 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option896, option898, option900})
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyU32Type(option901)
+
+						case 9:
+							var option908 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option908 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option903 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option903 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant902 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant902 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant902 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant902 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option903 = witTypes.Some[golem_core_types.NumericBound](variant902)
+								default:
+									panic("unreachable")
+								}
+								var option905 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option905 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant904 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant904 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant904 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant904 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option905 = witTypes.Some[golem_core_types.NumericBound](variant904)
+								default:
+									panic("unreachable")
+								}
+								var option907 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option907 = witTypes.None[string]()
+								case 1:
+									value906 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option907 = witTypes.Some[string](value906)
+								default:
+									panic("unreachable")
+								}
+
+								option908 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option903, option905, option907})
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyU64Type(option908)
+
+						case 10:
+							var option915 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option915 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option910 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option910 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant909 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant909 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant909 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant909 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option910 = witTypes.Some[golem_core_types.NumericBound](variant909)
+								default:
+									panic("unreachable")
+								}
+								var option912 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option912 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant911 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant911 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant911 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant911 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option912 = witTypes.Some[golem_core_types.NumericBound](variant911)
+								default:
+									panic("unreachable")
+								}
+								var option914 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option914 = witTypes.None[string]()
+								case 1:
+									value913 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option914 = witTypes.Some[string](value913)
+								default:
+									panic("unreachable")
+								}
+
+								option915 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option910, option912, option914})
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyF32Type(option915)
+
+						case 11:
+							var option922 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option922 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option917 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option917 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant916 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant916 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant916 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant916 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option917 = witTypes.Some[golem_core_types.NumericBound](variant916)
+								default:
+									panic("unreachable")
+								}
+								var option919 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option919 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant918 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant918 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant918 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant918 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option919 = witTypes.Some[golem_core_types.NumericBound](variant918)
+								default:
+									panic("unreachable")
+								}
+								var option921 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option921 = witTypes.None[string]()
+								case 1:
+									value920 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option921 = witTypes.Some[string](value920)
+								default:
+									panic("unreachable")
+								}
+
+								option922 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option917, option919, option921})
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyF64Type(option922)
+
+						case 12:
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result935 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value923 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option925 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option925 = witTypes.None[string]()
+								case 1:
+									value924 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option925 = witTypes.Some[string](value924)
+								default:
+									panic("unreachable")
+								}
+								result927 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value926 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result927 = append(result927, value926)
+								}
+
+								result929 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value928 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result929 = append(result929, value928)
+								}
+
+								var option931 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option931 = witTypes.None[string]()
+								case 1:
+									value930 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option931 = witTypes.Some[string](value930)
+								default:
+									panic("unreachable")
+								}
+								var option934 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option934 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant933 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant933 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant933 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant933 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value932 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant933 = golem_core_types.MakeRoleOther(value932)
+
+									default:
+										panic("unreachable")
+									}
+
+									option934 = witTypes.Some[golem_core_types.Role](variant933)
+								default:
+									panic("unreachable")
+								}
+
+								result935 = append(result935, golem_core_types.NamedFieldType{value923, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option925, result927, result929, option931, option934}})
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyRecordType(result935)
+
+						case 15:
+							result949 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value936 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option937 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option937 = witTypes.None[int32]()
+								case 1:
+
+									option937 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option939 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option939 = witTypes.None[string]()
+								case 1:
+									value938 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option939 = witTypes.Some[string](value938)
+								default:
+									panic("unreachable")
+								}
+								result941 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value940 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result941 = append(result941, value940)
+								}
+
+								result943 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value942 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result943 = append(result943, value942)
+								}
+
+								var option945 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option945 = witTypes.None[string]()
+								case 1:
+									value944 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option945 = witTypes.Some[string](value944)
+								default:
+									panic("unreachable")
+								}
+								var option948 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option948 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant947 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant947 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant947 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant947 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value946 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant947 = golem_core_types.MakeRoleOther(value946)
+
+									default:
+										panic("unreachable")
+									}
+
+									option948 = witTypes.Some[golem_core_types.Role](variant947)
+								default:
+									panic("unreachable")
+								}
+
+								result949 = append(result949, golem_core_types.VariantCaseType{value936, option937, golem_core_types.MetadataEnvelope{option939, result941, result943, option945, option948}})
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyVariantType(result949)
+
+						case 16:
+							result951 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value950 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result951 = append(result951, value950)
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyEnumType(result951)
+
+						case 17:
+							result953 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value952 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result953 = append(result953, value952)
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyFlagsType(result953)
+
+						case 18:
+							result954 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result954 = append(result954, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyTupleType(result954)
+
+						case 19:
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option955 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option955 = witTypes.None[int32]()
+							case 1:
+
+								option955 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option956 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option956 = witTypes.None[int32]()
+							case 1:
+
+								option956 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option955, option956})
+
+						case 24:
+							var option959 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option959 = witTypes.None[[]string]()
+							case 1:
+								result958 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value957 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result958 = append(result958, value957)
+								}
+
+								option959 = witTypes.Some[[]string](result958)
+							default:
+								panic("unreachable")
+							}
+							var option960 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option960 = witTypes.None[uint32]()
+							case 1:
+
+								option960 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option961 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option961 = witTypes.None[uint32]()
+							case 1:
+
+								option961 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option963 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option963 = witTypes.None[string]()
+							case 1:
+								value962 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option963 = witTypes.Some[string](value962)
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option959, option960, option961, option963})
+
+						case 25:
+							var option966 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option966 = witTypes.None[[]string]()
+							case 1:
+								result965 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value964 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result965 = append(result965, value964)
+								}
+
+								option966 = witTypes.Some[[]string](result965)
+							default:
+								panic("unreachable")
+							}
+							var option967 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option967 = witTypes.None[uint32]()
+							case 1:
+
+								option967 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option968 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option968 = witTypes.None[uint32]()
+							case 1:
+
+								option968 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option966, option967, option968})
+
+						case 26:
+							var option971 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option971 = witTypes.None[[]string]()
+							case 1:
+								result970 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value969 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result970 = append(result970, value969)
+								}
+
+								option971 = witTypes.Some[[]string](result970)
+							default:
+								panic("unreachable")
+							}
+							var option974 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option974 = witTypes.None[[]string]()
+							case 1:
+								result973 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value972 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result973 = append(result973, value972)
+								}
+
+								option974 = witTypes.Some[[]string](result973)
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option971, option974})
+
+						case 27:
+							var option977 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option977 = witTypes.None[[]string]()
+							case 1:
+								result976 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value975 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result976 = append(result976, value975)
+								}
+
+								option977 = witTypes.Some[[]string](result976)
+							default:
+								panic("unreachable")
+							}
+							var option980 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option980 = witTypes.None[[]string]()
+							case 1:
+								result979 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value978 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result979 = append(result979, value978)
+								}
+
+								option980 = witTypes.Some[[]string](result979)
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option977, option980})
+
+						case 28:
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value981 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result983 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value982 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result983 = append(result983, value982)
+							}
+
+							var option985 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option985 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value984 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option985 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value984})
+							default:
+								panic("unreachable")
+							}
+							var option987 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option987 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value986 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option987 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value986})
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value981, result983, option985, option987})
+
+						case 31:
+							result1009 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value988 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant997 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value989 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant997 = golem_core_types.MakeDiscriminatorRulePrefix(value989)
+
+								case 1:
+									value990 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant997 = golem_core_types.MakeDiscriminatorRuleSuffix(value990)
+
+								case 2:
+									value991 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant997 = golem_core_types.MakeDiscriminatorRuleContains(value991)
+
+								case 3:
+									value992 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant997 = golem_core_types.MakeDiscriminatorRuleRegex(value992)
+
+								case 4:
+									value993 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option995 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option995 = witTypes.None[string]()
+									case 1:
+										value994 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option995 = witTypes.Some[string](value994)
+									default:
+										panic("unreachable")
+									}
+
+									variant997 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value993, option995})
+
+								case 5:
+									value996 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant997 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value996)
+
+								default:
+									panic("unreachable")
+								}
+								var option999 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option999 = witTypes.None[string]()
+								case 1:
+									value998 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option999 = witTypes.Some[string](value998)
+								default:
+									panic("unreachable")
+								}
+								result1001 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value1000 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1001 = append(result1001, value1000)
+								}
+
+								result1003 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value1002 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1003 = append(result1003, value1002)
+								}
+
+								var option1005 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option1005 = witTypes.None[string]()
+								case 1:
+									value1004 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option1005 = witTypes.Some[string](value1004)
+								default:
+									panic("unreachable")
+								}
+								var option1008 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option1008 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1007 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant1007 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1007 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1007 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1006 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant1007 = golem_core_types.MakeRoleOther(value1006)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1008 = witTypes.Some[golem_core_types.Role](variant1007)
+								default:
+									panic("unreachable")
+								}
+
+								result1009 = append(result1009, golem_core_types.UnionBranch{value988, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant997, golem_core_types.MetadataEnvelope{option999, result1001, result1003, option1005, option1008}})
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1009})
+
+						case 32:
+							var option1011 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1011 = witTypes.None[string]()
+							case 1:
+								value1010 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option1011 = witTypes.Some[string](value1010)
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1011})
+
+						case 33:
+							var option1013 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1013 = witTypes.None[string]()
+							case 1:
+								value1012 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option1013 = witTypes.Some[string](value1012)
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1013})
+
+						case 34:
+							var option1014 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1014 = witTypes.None[int32]()
+							case 1:
+
+								option1014 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyFutureType(option1014)
+
+						case 35:
+							var option1015 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1015 = witTypes.None[int32]()
+							case 1:
+
+								option1015 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1016 = golem_core_types.MakeSchemaTypeBodyStreamType(option1015)
+
+						default:
+							panic("unreachable")
+						}
+						var option1018 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option1018 = witTypes.None[string]()
+						case 1:
+							value1017 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option1018 = witTypes.Some[string](value1017)
+						default:
+							panic("unreachable")
+						}
+						result1020 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value1019 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1020 = append(result1020, value1019)
+						}
+
+						result1022 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value1021 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1022 = append(result1022, value1021)
+						}
+
+						var option1024 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option1024 = witTypes.None[string]()
+						case 1:
+							value1023 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option1024 = witTypes.Some[string](value1023)
+						default:
+							panic("unreachable")
+						}
+						var option1027 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option1027 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant1026 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant1026 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant1026 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant1026 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value1025 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant1026 = golem_core_types.MakeRoleOther(value1025)
+
+							default:
+								panic("unreachable")
+							}
+
+							option1027 = witTypes.Some[golem_core_types.Role](variant1026)
+						default:
+							panic("unreachable")
+						}
+
+						result1028 = append(result1028, golem_core_types.SchemaTypeNode{variant1016, golem_core_types.MetadataEnvelope{option1018, result1020, result1022, option1024, option1027}})
+					}
+
+					result1032 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))), index*(6*4))
+						value1029 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option1031 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option1031 = witTypes.None[string]()
+						case 1:
+							value1030 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option1031 = witTypes.Some[string](value1030)
+						default:
+							panic("unreachable")
+						}
+
+						result1032 = append(result1032, golem_core_types.SchemaTypeDef{value1029, option1031, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result1056 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))))), index*(16+4*4))
+						var variant1055 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value1033 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeStringValue(value1033)
+
+						case 13:
+							result1034 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1034 = append(result1034, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeRecordValue(result1034)
+
+						case 14:
+							var option1035 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option1035 = witTypes.None[int32]()
+							case 1:
+
+								option1035 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1035})
+
+						case 15:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result1036 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result1036 = append(result1036, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1036)
+
+						case 17:
+							result1037 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1037 = append(result1037, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeTupleValue(result1037)
+
+						case 18:
+							result1038 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1038 = append(result1038, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeListValue(result1038)
+
+						case 19:
+							result1039 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1039 = append(result1039, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1039)
+
+						case 20:
+							result1040 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result1040 = append(result1040, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeMapValue(result1040)
+
+						case 21:
+							var option1041 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1041 = witTypes.None[int32]()
+							case 1:
+
+								option1041 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeOptionValue(option1041)
+
+						case 22:
+							var variant1044 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option1042 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1042 = witTypes.None[int32]()
+								case 1:
+
+									option1042 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1044 = golem_core_types.MakeResultValuePayloadOkValue(option1042)
+
+							case 1:
+								var option1043 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1043 = witTypes.None[int32]()
+								case 1:
+
+									option1043 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1044 = golem_core_types.MakeResultValuePayloadErrValue(option1043)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeResultValue(variant1044)
+
+						case 23:
+							value1045 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1047 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1047 = witTypes.None[string]()
+							case 1:
+								value1046 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1047 = witTypes.Some[string](value1046)
+							default:
+								panic("unreachable")
+							}
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1045, option1047})
+
+						case 24:
+							value1048 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1050 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1050 = witTypes.None[string]()
+							case 1:
+								value1049 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1050 = witTypes.Some[string](value1049)
+							default:
+								panic("unreachable")
+							}
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1048, option1050})
+
+						case 25:
+							value1051 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1055 = golem_core_types.MakeSchemaValueNodePathValue(value1051)
+
+						case 26:
+							value1052 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeUrlValue(value1052)
+
+						case 27:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value1053 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1053})
+
+						case 30:
+							value1054 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1054, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant1055 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result1056 = append(result1056, variant1055)
+					}
+
+					option1057 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1028, result1032, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result1056, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}})
+				default:
+					panic("unreachable")
+				}
+
+				variant2693 = MakePublicOplogEntryCancelled(CancelledParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), option1057})
+
+			case 4:
+				var variant1502 AgentInvocation
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+				case 0:
+					value1058 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+					result1234 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))), index*(56+22*4))
+						var variant1222 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option1065 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1065 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1060 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1060 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1059 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1059 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1059 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1059 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1060 = witTypes.Some[golem_core_types.NumericBound](variant1059)
+								default:
+									panic("unreachable")
+								}
+								var option1062 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1062 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1061 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1061 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1061 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1061 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1062 = witTypes.Some[golem_core_types.NumericBound](variant1061)
+								default:
+									panic("unreachable")
+								}
+								var option1064 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1064 = witTypes.None[string]()
+								case 1:
+									value1063 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1064 = witTypes.Some[string](value1063)
+								default:
+									panic("unreachable")
+								}
+
+								option1065 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1060, option1062, option1064})
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyS8Type(option1065)
+
+						case 3:
+							var option1072 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1072 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1067 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1067 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1066 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1066 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1066 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1066 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1067 = witTypes.Some[golem_core_types.NumericBound](variant1066)
+								default:
+									panic("unreachable")
+								}
+								var option1069 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1069 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1068 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1068 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1068 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1068 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1069 = witTypes.Some[golem_core_types.NumericBound](variant1068)
+								default:
+									panic("unreachable")
+								}
+								var option1071 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1071 = witTypes.None[string]()
+								case 1:
+									value1070 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1071 = witTypes.Some[string](value1070)
+								default:
+									panic("unreachable")
+								}
+
+								option1072 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1067, option1069, option1071})
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyS16Type(option1072)
+
+						case 4:
+							var option1079 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1079 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1074 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1074 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1073 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1073 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1073 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1073 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1074 = witTypes.Some[golem_core_types.NumericBound](variant1073)
+								default:
+									panic("unreachable")
+								}
+								var option1076 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1076 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1075 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1075 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1075 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1075 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1076 = witTypes.Some[golem_core_types.NumericBound](variant1075)
+								default:
+									panic("unreachable")
+								}
+								var option1078 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1078 = witTypes.None[string]()
+								case 1:
+									value1077 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1078 = witTypes.Some[string](value1077)
+								default:
+									panic("unreachable")
+								}
+
+								option1079 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1074, option1076, option1078})
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyS32Type(option1079)
+
+						case 5:
+							var option1086 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1086 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1081 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1081 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1080 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1080 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1080 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1080 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1081 = witTypes.Some[golem_core_types.NumericBound](variant1080)
+								default:
+									panic("unreachable")
+								}
+								var option1083 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1083 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1082 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1082 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1082 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1082 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1083 = witTypes.Some[golem_core_types.NumericBound](variant1082)
+								default:
+									panic("unreachable")
+								}
+								var option1085 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1085 = witTypes.None[string]()
+								case 1:
+									value1084 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1085 = witTypes.Some[string](value1084)
+								default:
+									panic("unreachable")
+								}
+
+								option1086 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1081, option1083, option1085})
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyS64Type(option1086)
+
+						case 6:
+							var option1093 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1093 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1088 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1088 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1087 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1087 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1087 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1087 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1088 = witTypes.Some[golem_core_types.NumericBound](variant1087)
+								default:
+									panic("unreachable")
+								}
+								var option1090 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1090 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1089 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1089 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1089 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1089 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1090 = witTypes.Some[golem_core_types.NumericBound](variant1089)
+								default:
+									panic("unreachable")
+								}
+								var option1092 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1092 = witTypes.None[string]()
+								case 1:
+									value1091 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1092 = witTypes.Some[string](value1091)
+								default:
+									panic("unreachable")
+								}
+
+								option1093 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1088, option1090, option1092})
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyU8Type(option1093)
+
+						case 7:
+							var option1100 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1100 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1095 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1095 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1094 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1094 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1094 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1094 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1095 = witTypes.Some[golem_core_types.NumericBound](variant1094)
+								default:
+									panic("unreachable")
+								}
+								var option1097 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1097 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1096 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1096 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1096 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1096 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1097 = witTypes.Some[golem_core_types.NumericBound](variant1096)
+								default:
+									panic("unreachable")
+								}
+								var option1099 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1099 = witTypes.None[string]()
+								case 1:
+									value1098 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1099 = witTypes.Some[string](value1098)
+								default:
+									panic("unreachable")
+								}
+
+								option1100 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1095, option1097, option1099})
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyU16Type(option1100)
+
+						case 8:
+							var option1107 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1107 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1102 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1102 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1101 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1101 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1101 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1101 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1102 = witTypes.Some[golem_core_types.NumericBound](variant1101)
+								default:
+									panic("unreachable")
+								}
+								var option1104 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1104 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1103 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1103 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1103 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1103 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1104 = witTypes.Some[golem_core_types.NumericBound](variant1103)
+								default:
+									panic("unreachable")
+								}
+								var option1106 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1106 = witTypes.None[string]()
+								case 1:
+									value1105 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1106 = witTypes.Some[string](value1105)
+								default:
+									panic("unreachable")
+								}
+
+								option1107 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1102, option1104, option1106})
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyU32Type(option1107)
+
+						case 9:
+							var option1114 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1114 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1109 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1109 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1108 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1108 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1108 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1108 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1109 = witTypes.Some[golem_core_types.NumericBound](variant1108)
+								default:
+									panic("unreachable")
+								}
+								var option1111 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1111 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1110 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1110 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1110 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1110 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1111 = witTypes.Some[golem_core_types.NumericBound](variant1110)
+								default:
+									panic("unreachable")
+								}
+								var option1113 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1113 = witTypes.None[string]()
+								case 1:
+									value1112 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1113 = witTypes.Some[string](value1112)
+								default:
+									panic("unreachable")
+								}
+
+								option1114 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1109, option1111, option1113})
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyU64Type(option1114)
+
+						case 10:
+							var option1121 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1121 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1116 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1116 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1115 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1115 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1115 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1115 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1116 = witTypes.Some[golem_core_types.NumericBound](variant1115)
+								default:
+									panic("unreachable")
+								}
+								var option1118 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1118 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1117 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1117 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1117 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1117 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1118 = witTypes.Some[golem_core_types.NumericBound](variant1117)
+								default:
+									panic("unreachable")
+								}
+								var option1120 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1120 = witTypes.None[string]()
+								case 1:
+									value1119 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1120 = witTypes.Some[string](value1119)
+								default:
+									panic("unreachable")
+								}
+
+								option1121 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1116, option1118, option1120})
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyF32Type(option1121)
+
+						case 11:
+							var option1128 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1128 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1123 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1123 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1122 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1122 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1122 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1122 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1123 = witTypes.Some[golem_core_types.NumericBound](variant1122)
+								default:
+									panic("unreachable")
+								}
+								var option1125 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1125 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1124 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1124 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1124 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1124 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1125 = witTypes.Some[golem_core_types.NumericBound](variant1124)
+								default:
+									panic("unreachable")
+								}
+								var option1127 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1127 = witTypes.None[string]()
+								case 1:
+									value1126 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1127 = witTypes.Some[string](value1126)
+								default:
+									panic("unreachable")
+								}
+
+								option1128 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1123, option1125, option1127})
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyF64Type(option1128)
+
+						case 12:
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result1141 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value1129 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1131 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option1131 = witTypes.None[string]()
+								case 1:
+									value1130 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option1131 = witTypes.Some[string](value1130)
+								default:
+									panic("unreachable")
+								}
+								result1133 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value1132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1133 = append(result1133, value1132)
+								}
+
+								result1135 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value1134 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1135 = append(result1135, value1134)
+								}
+
+								var option1137 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option1137 = witTypes.None[string]()
+								case 1:
+									value1136 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option1137 = witTypes.Some[string](value1136)
+								default:
+									panic("unreachable")
+								}
+								var option1140 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option1140 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1139 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant1139 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1139 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1139 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1138 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant1139 = golem_core_types.MakeRoleOther(value1138)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1140 = witTypes.Some[golem_core_types.Role](variant1139)
+								default:
+									panic("unreachable")
+								}
+
+								result1141 = append(result1141, golem_core_types.NamedFieldType{value1129, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1131, result1133, result1135, option1137, option1140}})
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyRecordType(result1141)
+
+						case 15:
+							result1155 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value1142 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1143 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option1143 = witTypes.None[int32]()
+								case 1:
+
+									option1143 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option1145 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option1145 = witTypes.None[string]()
+								case 1:
+									value1144 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option1145 = witTypes.Some[string](value1144)
+								default:
+									panic("unreachable")
+								}
+								result1147 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1147 = append(result1147, value1146)
+								}
+
+								result1149 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value1148 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1149 = append(result1149, value1148)
+								}
+
+								var option1151 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option1151 = witTypes.None[string]()
+								case 1:
+									value1150 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option1151 = witTypes.Some[string](value1150)
+								default:
+									panic("unreachable")
+								}
+								var option1154 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option1154 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1153 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant1153 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1153 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1153 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1152 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant1153 = golem_core_types.MakeRoleOther(value1152)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1154 = witTypes.Some[golem_core_types.Role](variant1153)
+								default:
+									panic("unreachable")
+								}
+
+								result1155 = append(result1155, golem_core_types.VariantCaseType{value1142, option1143, golem_core_types.MetadataEnvelope{option1145, result1147, result1149, option1151, option1154}})
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyVariantType(result1155)
+
+						case 16:
+							result1157 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1156 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1157 = append(result1157, value1156)
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyEnumType(result1157)
+
+						case 17:
+							result1159 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1158 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1159 = append(result1159, value1158)
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1159)
+
+						case 18:
+							result1160 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1160 = append(result1160, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyTupleType(result1160)
+
+						case 19:
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option1161 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1161 = witTypes.None[int32]()
+							case 1:
+
+								option1161 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option1162 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option1162 = witTypes.None[int32]()
+							case 1:
+
+								option1162 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1161, option1162})
+
+						case 24:
+							var option1165 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1165 = witTypes.None[[]string]()
+							case 1:
+								result1164 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1163 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1164 = append(result1164, value1163)
+								}
+
+								option1165 = witTypes.Some[[]string](result1164)
+							default:
+								panic("unreachable")
+							}
+							var option1166 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1166 = witTypes.None[uint32]()
+							case 1:
+
+								option1166 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1167 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1167 = witTypes.None[uint32]()
+							case 1:
+
+								option1167 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1169 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option1169 = witTypes.None[string]()
+							case 1:
+								value1168 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option1169 = witTypes.Some[string](value1168)
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1165, option1166, option1167, option1169})
+
+						case 25:
+							var option1172 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1172 = witTypes.None[[]string]()
+							case 1:
+								result1171 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1170 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1171 = append(result1171, value1170)
+								}
+
+								option1172 = witTypes.Some[[]string](result1171)
+							default:
+								panic("unreachable")
+							}
+							var option1173 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1173 = witTypes.None[uint32]()
+							case 1:
+
+								option1173 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1174 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1174 = witTypes.None[uint32]()
+							case 1:
+
+								option1174 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1172, option1173, option1174})
+
+						case 26:
+							var option1177 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1177 = witTypes.None[[]string]()
+							case 1:
+								result1176 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value1175 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1176 = append(result1176, value1175)
+								}
+
+								option1177 = witTypes.Some[[]string](result1176)
+							default:
+								panic("unreachable")
+							}
+							var option1180 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1180 = witTypes.None[[]string]()
+							case 1:
+								result1179 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1178 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1179 = append(result1179, value1178)
+								}
+
+								option1180 = witTypes.Some[[]string](result1179)
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option1177, option1180})
+
+						case 27:
+							var option1183 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1183 = witTypes.None[[]string]()
+							case 1:
+								result1182 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1181 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1182 = append(result1182, value1181)
+								}
+
+								option1183 = witTypes.Some[[]string](result1182)
+							default:
+								panic("unreachable")
+							}
+							var option1186 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1186 = witTypes.None[[]string]()
+							case 1:
+								result1185 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value1184 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1185 = append(result1185, value1184)
+								}
+
+								option1186 = witTypes.Some[[]string](result1185)
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1183, option1186})
+
+						case 28:
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value1187 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result1189 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value1188 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1189 = append(result1189, value1188)
+							}
+
+							var option1191 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1191 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1190 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option1191 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value1190})
+							default:
+								panic("unreachable")
+							}
+							var option1193 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option1193 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1192 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option1193 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value1192})
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1187, result1189, option1191, option1193})
+
+						case 31:
+							result1215 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value1194 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant1203 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value1195 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1203 = golem_core_types.MakeDiscriminatorRulePrefix(value1195)
+
+								case 1:
+									value1196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1203 = golem_core_types.MakeDiscriminatorRuleSuffix(value1196)
+
+								case 2:
+									value1197 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1203 = golem_core_types.MakeDiscriminatorRuleContains(value1197)
+
+								case 3:
+									value1198 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1203 = golem_core_types.MakeDiscriminatorRuleRegex(value1198)
+
+								case 4:
+									value1199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option1201 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option1201 = witTypes.None[string]()
+									case 1:
+										value1200 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option1201 = witTypes.Some[string](value1200)
+									default:
+										panic("unreachable")
+									}
+
+									variant1203 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1199, option1201})
+
+								case 5:
+									value1202 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1203 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1202)
+
+								default:
+									panic("unreachable")
+								}
+								var option1205 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option1205 = witTypes.None[string]()
+								case 1:
+									value1204 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option1205 = witTypes.Some[string](value1204)
+								default:
+									panic("unreachable")
+								}
+								result1207 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value1206 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1207 = append(result1207, value1206)
+								}
+
+								result1209 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value1208 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1209 = append(result1209, value1208)
+								}
+
+								var option1211 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option1211 = witTypes.None[string]()
+								case 1:
+									value1210 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option1211 = witTypes.Some[string](value1210)
+								default:
+									panic("unreachable")
+								}
+								var option1214 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option1214 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1213 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant1213 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1213 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1213 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1212 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant1213 = golem_core_types.MakeRoleOther(value1212)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1214 = witTypes.Some[golem_core_types.Role](variant1213)
+								default:
+									panic("unreachable")
+								}
+
+								result1215 = append(result1215, golem_core_types.UnionBranch{value1194, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1203, golem_core_types.MetadataEnvelope{option1205, result1207, result1209, option1211, option1214}})
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1215})
+
+						case 32:
+							var option1217 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1217 = witTypes.None[string]()
+							case 1:
+								value1216 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option1217 = witTypes.Some[string](value1216)
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1217})
+
+						case 33:
+							var option1219 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1219 = witTypes.None[string]()
+							case 1:
+								value1218 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option1219 = witTypes.Some[string](value1218)
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1219})
+
+						case 34:
+							var option1220 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1220 = witTypes.None[int32]()
+							case 1:
+
+								option1220 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyFutureType(option1220)
+
+						case 35:
+							var option1221 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1221 = witTypes.None[int32]()
+							case 1:
+
+								option1221 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1222 = golem_core_types.MakeSchemaTypeBodyStreamType(option1221)
+
+						default:
+							panic("unreachable")
+						}
+						var option1224 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option1224 = witTypes.None[string]()
+						case 1:
+							value1223 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option1224 = witTypes.Some[string](value1223)
+						default:
+							panic("unreachable")
+						}
+						result1226 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value1225 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1226 = append(result1226, value1225)
+						}
+
+						result1228 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value1227 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1228 = append(result1228, value1227)
+						}
+
+						var option1230 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option1230 = witTypes.None[string]()
+						case 1:
+							value1229 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option1230 = witTypes.Some[string](value1229)
+						default:
+							panic("unreachable")
+						}
+						var option1233 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option1233 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant1232 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant1232 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant1232 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant1232 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value1231 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant1232 = golem_core_types.MakeRoleOther(value1231)
+
+							default:
+								panic("unreachable")
+							}
+
+							option1233 = witTypes.Some[golem_core_types.Role](variant1232)
+						default:
+							panic("unreachable")
+						}
+
+						result1234 = append(result1234, golem_core_types.SchemaTypeNode{variant1222, golem_core_types.MetadataEnvelope{option1224, result1226, result1228, option1230, option1233}})
+					}
+
+					result1238 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))), index*(6*4))
+						value1235 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option1237 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option1237 = witTypes.None[string]()
+						case 1:
+							value1236 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option1237 = witTypes.Some[string](value1236)
+						default:
+							panic("unreachable")
+						}
+
+						result1238 = append(result1238, golem_core_types.SchemaTypeDef{value1235, option1237, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result1262 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))), index*(16+4*4))
+						var variant1261 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value1239 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeStringValue(value1239)
+
+						case 13:
+							result1240 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1240 = append(result1240, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeRecordValue(result1240)
+
+						case 14:
+							var option1241 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option1241 = witTypes.None[int32]()
+							case 1:
+
+								option1241 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1241})
+
+						case 15:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result1242 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result1242 = append(result1242, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1242)
+
+						case 17:
+							result1243 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1243 = append(result1243, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeTupleValue(result1243)
+
+						case 18:
+							result1244 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1244 = append(result1244, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeListValue(result1244)
+
+						case 19:
+							result1245 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1245 = append(result1245, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1245)
+
+						case 20:
+							result1246 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result1246 = append(result1246, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeMapValue(result1246)
+
+						case 21:
+							var option1247 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1247 = witTypes.None[int32]()
+							case 1:
+
+								option1247 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeOptionValue(option1247)
+
+						case 22:
+							var variant1250 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option1248 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1248 = witTypes.None[int32]()
+								case 1:
+
+									option1248 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1250 = golem_core_types.MakeResultValuePayloadOkValue(option1248)
+
+							case 1:
+								var option1249 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1249 = witTypes.None[int32]()
+								case 1:
+
+									option1249 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1250 = golem_core_types.MakeResultValuePayloadErrValue(option1249)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeResultValue(variant1250)
+
+						case 23:
+							value1251 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1253 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1253 = witTypes.None[string]()
+							case 1:
+								value1252 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1253 = witTypes.Some[string](value1252)
+							default:
+								panic("unreachable")
+							}
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1251, option1253})
+
+						case 24:
+							value1254 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1256 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1256 = witTypes.None[string]()
+							case 1:
+								value1255 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1256 = witTypes.Some[string](value1255)
+							default:
+								panic("unreachable")
+							}
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1254, option1256})
+
+						case 25:
+							value1257 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1261 = golem_core_types.MakeSchemaValueNodePathValue(value1257)
+
+						case 26:
+							value1258 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeUrlValue(value1258)
+
+						case 27:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value1259 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1259})
+
+						case 30:
+							value1260 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1260, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant1261 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result1262 = append(result1262, variant1261)
+					}
+
+					value1263 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4))))
+					result1265 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))))), index*(2*4))
+						value1264 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result1265 = append(result1265, value1264)
+					}
+
+					result1277 := make([][]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 14*4))))), index*(2*4))
+						result1276 := make([]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*(56+6*4))
+							var variant1275 SpanData
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value1266 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var option1268 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) {
+								case 0:
+
+									option1268 = witTypes.None[string]()
+								case 1:
+									value1267 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+									option1268 = witTypes.Some[string](value1267)
+								default:
+									panic("unreachable")
+								}
+								var option1269 witTypes.Option[uint64]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) {
+								case 0:
+
+									option1269 = witTypes.None[uint64]()
+								case 1:
+
+									option1269 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))))
+								default:
+									panic("unreachable")
+								}
+								result1273 := make([]golem_api_context.Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))), index*(5*4))
+									value1270 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+									var variant1272 golem_api_context.AttributeValue
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+									case 0:
+										value1271 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+										variant1272 = golem_api_context.MakeAttributeValueString(value1271)
+
+									default:
+										panic("unreachable")
+									}
+
+									result1273 = append(result1273, golem_api_context.Attribute{value1270, variant1272})
+								}
+
+								variant1275 = MakeSpanDataLocalSpan(LocalSpanData{value1266, wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))}, option1268, option1269, result1273, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)})
+
+							case 1:
+								value1274 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant1275 = MakeSpanDataExternalSpan(ExternalSpanData{value1274})
+
+							default:
+								panic("unreachable")
+							}
+
+							result1276 = append(result1276, variant1275)
+						}
+
+						result1277 = append(result1277, result1276)
+					}
+
+					variant1502 = MakeAgentInvocationAgentInitialization(AgentInitializationParameters{value1058, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1234, result1238, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))}, golem_core_types.SchemaValueTree{result1262, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4)))}}, value1263, result1265, result1277})
+
+				case 1:
+					value1278 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+					value1279 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+					result1455 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))), index*(56+22*4))
+						var variant1443 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option1286 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1286 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1281 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1281 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1280 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1280 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1280 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1280 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1281 = witTypes.Some[golem_core_types.NumericBound](variant1280)
+								default:
+									panic("unreachable")
+								}
+								var option1283 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1283 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1282 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1282 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1282 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1282 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1283 = witTypes.Some[golem_core_types.NumericBound](variant1282)
+								default:
+									panic("unreachable")
+								}
+								var option1285 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1285 = witTypes.None[string]()
+								case 1:
+									value1284 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1285 = witTypes.Some[string](value1284)
+								default:
+									panic("unreachable")
+								}
+
+								option1286 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1281, option1283, option1285})
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyS8Type(option1286)
+
+						case 3:
+							var option1293 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1293 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1288 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1288 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1287 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1287 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1287 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1287 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1288 = witTypes.Some[golem_core_types.NumericBound](variant1287)
+								default:
+									panic("unreachable")
+								}
+								var option1290 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1290 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1289 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1289 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1289 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1289 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1290 = witTypes.Some[golem_core_types.NumericBound](variant1289)
+								default:
+									panic("unreachable")
+								}
+								var option1292 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1292 = witTypes.None[string]()
+								case 1:
+									value1291 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1292 = witTypes.Some[string](value1291)
+								default:
+									panic("unreachable")
+								}
+
+								option1293 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1288, option1290, option1292})
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyS16Type(option1293)
+
+						case 4:
+							var option1300 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1300 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1295 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1295 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1294 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1294 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1294 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1294 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1295 = witTypes.Some[golem_core_types.NumericBound](variant1294)
+								default:
+									panic("unreachable")
+								}
+								var option1297 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1297 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1296 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1296 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1296 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1296 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1297 = witTypes.Some[golem_core_types.NumericBound](variant1296)
+								default:
+									panic("unreachable")
+								}
+								var option1299 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1299 = witTypes.None[string]()
+								case 1:
+									value1298 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1299 = witTypes.Some[string](value1298)
+								default:
+									panic("unreachable")
+								}
+
+								option1300 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1295, option1297, option1299})
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyS32Type(option1300)
+
+						case 5:
+							var option1307 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1307 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1302 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1302 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1301 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1301 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1301 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1301 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1302 = witTypes.Some[golem_core_types.NumericBound](variant1301)
+								default:
+									panic("unreachable")
+								}
+								var option1304 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1304 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1303 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1303 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1303 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1303 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1304 = witTypes.Some[golem_core_types.NumericBound](variant1303)
+								default:
+									panic("unreachable")
+								}
+								var option1306 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1306 = witTypes.None[string]()
+								case 1:
+									value1305 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1306 = witTypes.Some[string](value1305)
+								default:
+									panic("unreachable")
+								}
+
+								option1307 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1302, option1304, option1306})
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyS64Type(option1307)
+
+						case 6:
+							var option1314 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1314 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1309 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1309 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1308 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1308 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1308 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1308 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1309 = witTypes.Some[golem_core_types.NumericBound](variant1308)
+								default:
+									panic("unreachable")
+								}
+								var option1311 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1311 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1310 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1310 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1310 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1310 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1311 = witTypes.Some[golem_core_types.NumericBound](variant1310)
+								default:
+									panic("unreachable")
+								}
+								var option1313 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1313 = witTypes.None[string]()
+								case 1:
+									value1312 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1313 = witTypes.Some[string](value1312)
+								default:
+									panic("unreachable")
+								}
+
+								option1314 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1309, option1311, option1313})
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyU8Type(option1314)
+
+						case 7:
+							var option1321 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1321 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1316 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1316 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1315 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1315 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1315 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1315 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1316 = witTypes.Some[golem_core_types.NumericBound](variant1315)
+								default:
+									panic("unreachable")
+								}
+								var option1318 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1318 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1317 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1317 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1317 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1317 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1318 = witTypes.Some[golem_core_types.NumericBound](variant1317)
+								default:
+									panic("unreachable")
+								}
+								var option1320 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1320 = witTypes.None[string]()
+								case 1:
+									value1319 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1320 = witTypes.Some[string](value1319)
+								default:
+									panic("unreachable")
+								}
+
+								option1321 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1316, option1318, option1320})
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyU16Type(option1321)
+
+						case 8:
+							var option1328 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1328 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1323 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1323 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1322 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1322 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1322 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1322 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1323 = witTypes.Some[golem_core_types.NumericBound](variant1322)
+								default:
+									panic("unreachable")
+								}
+								var option1325 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1325 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1324 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1324 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1324 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1324 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1325 = witTypes.Some[golem_core_types.NumericBound](variant1324)
+								default:
+									panic("unreachable")
+								}
+								var option1327 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1327 = witTypes.None[string]()
+								case 1:
+									value1326 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1327 = witTypes.Some[string](value1326)
+								default:
+									panic("unreachable")
+								}
+
+								option1328 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1323, option1325, option1327})
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyU32Type(option1328)
+
+						case 9:
+							var option1335 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1335 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1330 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1330 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1329 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1329 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1329 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1329 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1330 = witTypes.Some[golem_core_types.NumericBound](variant1329)
+								default:
+									panic("unreachable")
+								}
+								var option1332 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1332 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1331 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1331 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1331 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1331 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1332 = witTypes.Some[golem_core_types.NumericBound](variant1331)
+								default:
+									panic("unreachable")
+								}
+								var option1334 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1334 = witTypes.None[string]()
+								case 1:
+									value1333 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1334 = witTypes.Some[string](value1333)
+								default:
+									panic("unreachable")
+								}
+
+								option1335 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1330, option1332, option1334})
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyU64Type(option1335)
+
+						case 10:
+							var option1342 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1342 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1337 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1337 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1336 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1336 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1336 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1336 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1337 = witTypes.Some[golem_core_types.NumericBound](variant1336)
+								default:
+									panic("unreachable")
+								}
+								var option1339 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1339 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1338 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1338 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1338 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1338 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1339 = witTypes.Some[golem_core_types.NumericBound](variant1338)
+								default:
+									panic("unreachable")
+								}
+								var option1341 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1341 = witTypes.None[string]()
+								case 1:
+									value1340 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1341 = witTypes.Some[string](value1340)
+								default:
+									panic("unreachable")
+								}
+
+								option1342 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1337, option1339, option1341})
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyF32Type(option1342)
+
+						case 11:
+							var option1349 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1349 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1344 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1344 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1343 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1343 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1343 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1343 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1344 = witTypes.Some[golem_core_types.NumericBound](variant1343)
+								default:
+									panic("unreachable")
+								}
+								var option1346 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1346 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1345 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1345 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1345 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1345 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1346 = witTypes.Some[golem_core_types.NumericBound](variant1345)
+								default:
+									panic("unreachable")
+								}
+								var option1348 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1348 = witTypes.None[string]()
+								case 1:
+									value1347 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1348 = witTypes.Some[string](value1347)
+								default:
+									panic("unreachable")
+								}
+
+								option1349 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1344, option1346, option1348})
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyF64Type(option1349)
+
+						case 12:
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result1362 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value1350 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1352 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option1352 = witTypes.None[string]()
+								case 1:
+									value1351 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option1352 = witTypes.Some[string](value1351)
+								default:
+									panic("unreachable")
+								}
+								result1354 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value1353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1354 = append(result1354, value1353)
+								}
+
+								result1356 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value1355 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1356 = append(result1356, value1355)
+								}
+
+								var option1358 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option1358 = witTypes.None[string]()
+								case 1:
+									value1357 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option1358 = witTypes.Some[string](value1357)
+								default:
+									panic("unreachable")
+								}
+								var option1361 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option1361 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1360 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant1360 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1360 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1360 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1359 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant1360 = golem_core_types.MakeRoleOther(value1359)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1361 = witTypes.Some[golem_core_types.Role](variant1360)
+								default:
+									panic("unreachable")
+								}
+
+								result1362 = append(result1362, golem_core_types.NamedFieldType{value1350, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1352, result1354, result1356, option1358, option1361}})
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyRecordType(result1362)
+
+						case 15:
+							result1376 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value1363 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1364 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option1364 = witTypes.None[int32]()
+								case 1:
+
+									option1364 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option1366 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option1366 = witTypes.None[string]()
+								case 1:
+									value1365 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option1366 = witTypes.Some[string](value1365)
+								default:
+									panic("unreachable")
+								}
+								result1368 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1367 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1368 = append(result1368, value1367)
+								}
+
+								result1370 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value1369 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1370 = append(result1370, value1369)
+								}
+
+								var option1372 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option1372 = witTypes.None[string]()
+								case 1:
+									value1371 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option1372 = witTypes.Some[string](value1371)
+								default:
+									panic("unreachable")
+								}
+								var option1375 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option1375 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1374 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant1374 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1374 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1374 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1373 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant1374 = golem_core_types.MakeRoleOther(value1373)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1375 = witTypes.Some[golem_core_types.Role](variant1374)
+								default:
+									panic("unreachable")
+								}
+
+								result1376 = append(result1376, golem_core_types.VariantCaseType{value1363, option1364, golem_core_types.MetadataEnvelope{option1366, result1368, result1370, option1372, option1375}})
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyVariantType(result1376)
+
+						case 16:
+							result1378 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1377 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1378 = append(result1378, value1377)
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyEnumType(result1378)
+
+						case 17:
+							result1380 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1379 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1380 = append(result1380, value1379)
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1380)
+
+						case 18:
+							result1381 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1381 = append(result1381, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyTupleType(result1381)
+
+						case 19:
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option1382 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1382 = witTypes.None[int32]()
+							case 1:
+
+								option1382 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option1383 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option1383 = witTypes.None[int32]()
+							case 1:
+
+								option1383 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1382, option1383})
+
+						case 24:
+							var option1386 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1386 = witTypes.None[[]string]()
+							case 1:
+								result1385 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1384 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1385 = append(result1385, value1384)
+								}
+
+								option1386 = witTypes.Some[[]string](result1385)
+							default:
+								panic("unreachable")
+							}
+							var option1387 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1387 = witTypes.None[uint32]()
+							case 1:
+
+								option1387 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1388 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1388 = witTypes.None[uint32]()
+							case 1:
+
+								option1388 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1390 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option1390 = witTypes.None[string]()
+							case 1:
+								value1389 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option1390 = witTypes.Some[string](value1389)
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1386, option1387, option1388, option1390})
+
+						case 25:
+							var option1393 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1393 = witTypes.None[[]string]()
+							case 1:
+								result1392 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1391 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1392 = append(result1392, value1391)
+								}
+
+								option1393 = witTypes.Some[[]string](result1392)
+							default:
+								panic("unreachable")
+							}
+							var option1394 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1394 = witTypes.None[uint32]()
+							case 1:
+
+								option1394 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1395 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1395 = witTypes.None[uint32]()
+							case 1:
+
+								option1395 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1393, option1394, option1395})
+
+						case 26:
+							var option1398 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1398 = witTypes.None[[]string]()
+							case 1:
+								result1397 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value1396 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1397 = append(result1397, value1396)
+								}
+
+								option1398 = witTypes.Some[[]string](result1397)
+							default:
+								panic("unreachable")
+							}
+							var option1401 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1401 = witTypes.None[[]string]()
+							case 1:
+								result1400 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1399 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1400 = append(result1400, value1399)
+								}
+
+								option1401 = witTypes.Some[[]string](result1400)
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option1398, option1401})
+
+						case 27:
+							var option1404 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1404 = witTypes.None[[]string]()
+							case 1:
+								result1403 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1402 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1403 = append(result1403, value1402)
+								}
+
+								option1404 = witTypes.Some[[]string](result1403)
+							default:
+								panic("unreachable")
+							}
+							var option1407 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1407 = witTypes.None[[]string]()
+							case 1:
+								result1406 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value1405 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1406 = append(result1406, value1405)
+								}
+
+								option1407 = witTypes.Some[[]string](result1406)
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1404, option1407})
+
+						case 28:
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value1408 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result1410 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value1409 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1410 = append(result1410, value1409)
+							}
+
+							var option1412 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1412 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1411 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option1412 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value1411})
+							default:
+								panic("unreachable")
+							}
+							var option1414 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option1414 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1413 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option1414 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value1413})
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1408, result1410, option1412, option1414})
+
+						case 31:
+							result1436 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value1415 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant1424 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value1416 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1424 = golem_core_types.MakeDiscriminatorRulePrefix(value1416)
+
+								case 1:
+									value1417 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1424 = golem_core_types.MakeDiscriminatorRuleSuffix(value1417)
+
+								case 2:
+									value1418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1424 = golem_core_types.MakeDiscriminatorRuleContains(value1418)
+
+								case 3:
+									value1419 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1424 = golem_core_types.MakeDiscriminatorRuleRegex(value1419)
+
+								case 4:
+									value1420 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option1422 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option1422 = witTypes.None[string]()
+									case 1:
+										value1421 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option1422 = witTypes.Some[string](value1421)
+									default:
+										panic("unreachable")
+									}
+
+									variant1424 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1420, option1422})
+
+								case 5:
+									value1423 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1424 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1423)
+
+								default:
+									panic("unreachable")
+								}
+								var option1426 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option1426 = witTypes.None[string]()
+								case 1:
+									value1425 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option1426 = witTypes.Some[string](value1425)
+								default:
+									panic("unreachable")
+								}
+								result1428 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value1427 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1428 = append(result1428, value1427)
+								}
+
+								result1430 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value1429 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1430 = append(result1430, value1429)
+								}
+
+								var option1432 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option1432 = witTypes.None[string]()
+								case 1:
+									value1431 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option1432 = witTypes.Some[string](value1431)
+								default:
+									panic("unreachable")
+								}
+								var option1435 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option1435 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1434 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant1434 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1434 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1434 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1433 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant1434 = golem_core_types.MakeRoleOther(value1433)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1435 = witTypes.Some[golem_core_types.Role](variant1434)
+								default:
+									panic("unreachable")
+								}
+
+								result1436 = append(result1436, golem_core_types.UnionBranch{value1415, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1424, golem_core_types.MetadataEnvelope{option1426, result1428, result1430, option1432, option1435}})
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1436})
+
+						case 32:
+							var option1438 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1438 = witTypes.None[string]()
+							case 1:
+								value1437 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option1438 = witTypes.Some[string](value1437)
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1438})
+
+						case 33:
+							var option1440 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1440 = witTypes.None[string]()
+							case 1:
+								value1439 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option1440 = witTypes.Some[string](value1439)
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1440})
+
+						case 34:
+							var option1441 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1441 = witTypes.None[int32]()
+							case 1:
+
+								option1441 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyFutureType(option1441)
+
+						case 35:
+							var option1442 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1442 = witTypes.None[int32]()
+							case 1:
+
+								option1442 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1443 = golem_core_types.MakeSchemaTypeBodyStreamType(option1442)
+
+						default:
+							panic("unreachable")
+						}
+						var option1445 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option1445 = witTypes.None[string]()
+						case 1:
+							value1444 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option1445 = witTypes.Some[string](value1444)
+						default:
+							panic("unreachable")
+						}
+						result1447 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value1446 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1447 = append(result1447, value1446)
+						}
+
+						result1449 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value1448 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1449 = append(result1449, value1448)
+						}
+
+						var option1451 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option1451 = witTypes.None[string]()
+						case 1:
+							value1450 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option1451 = witTypes.Some[string](value1450)
+						default:
+							panic("unreachable")
+						}
+						var option1454 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option1454 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant1453 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant1453 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant1453 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant1453 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value1452 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant1453 = golem_core_types.MakeRoleOther(value1452)
+
+							default:
+								panic("unreachable")
+							}
+
+							option1454 = witTypes.Some[golem_core_types.Role](variant1453)
+						default:
+							panic("unreachable")
+						}
+
+						result1455 = append(result1455, golem_core_types.SchemaTypeNode{variant1443, golem_core_types.MetadataEnvelope{option1445, result1447, result1449, option1451, option1454}})
+					}
+
+					result1459 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))))), index*(6*4))
+						value1456 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option1458 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option1458 = witTypes.None[string]()
+						case 1:
+							value1457 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option1458 = witTypes.Some[string](value1457)
+						default:
+							panic("unreachable")
+						}
+
+						result1459 = append(result1459, golem_core_types.SchemaTypeDef{value1456, option1458, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result1483 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4))))), index*(16+4*4))
+						var variant1482 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value1460 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeStringValue(value1460)
+
+						case 13:
+							result1461 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1461 = append(result1461, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeRecordValue(result1461)
+
+						case 14:
+							var option1462 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option1462 = witTypes.None[int32]()
+							case 1:
+
+								option1462 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1462})
+
+						case 15:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result1463 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result1463 = append(result1463, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1463)
+
+						case 17:
+							result1464 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1464 = append(result1464, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeTupleValue(result1464)
+
+						case 18:
+							result1465 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1465 = append(result1465, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeListValue(result1465)
+
+						case 19:
+							result1466 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1466 = append(result1466, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1466)
+
+						case 20:
+							result1467 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result1467 = append(result1467, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeMapValue(result1467)
+
+						case 21:
+							var option1468 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1468 = witTypes.None[int32]()
+							case 1:
+
+								option1468 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeOptionValue(option1468)
+
+						case 22:
+							var variant1471 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option1469 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1469 = witTypes.None[int32]()
+								case 1:
+
+									option1469 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1471 = golem_core_types.MakeResultValuePayloadOkValue(option1469)
+
+							case 1:
+								var option1470 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1470 = witTypes.None[int32]()
+								case 1:
+
+									option1470 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1471 = golem_core_types.MakeResultValuePayloadErrValue(option1470)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeResultValue(variant1471)
+
+						case 23:
+							value1472 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1474 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1474 = witTypes.None[string]()
+							case 1:
+								value1473 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1474 = witTypes.Some[string](value1473)
+							default:
+								panic("unreachable")
+							}
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1472, option1474})
+
+						case 24:
+							value1475 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1477 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1477 = witTypes.None[string]()
+							case 1:
+								value1476 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1477 = witTypes.Some[string](value1476)
+							default:
+								panic("unreachable")
+							}
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1475, option1477})
+
+						case 25:
+							value1478 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1482 = golem_core_types.MakeSchemaValueNodePathValue(value1478)
+
+						case 26:
+							value1479 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeUrlValue(value1479)
+
+						case 27:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value1480 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1480})
+
+						case 30:
+							value1481 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1481, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant1482 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result1483 = append(result1483, variant1482)
+					}
+
+					value1484 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4))))
+					result1486 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 14*4))))), index*(2*4))
+						value1485 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result1486 = append(result1486, value1485)
+					}
+
+					result1498 := make([][]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 17*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 17*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 16*4))))), index*(2*4))
+						result1497 := make([]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*(56+6*4))
+							var variant1496 SpanData
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value1487 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var option1489 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) {
+								case 0:
+
+									option1489 = witTypes.None[string]()
+								case 1:
+									value1488 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+									option1489 = witTypes.Some[string](value1488)
+								default:
+									panic("unreachable")
+								}
+								var option1490 witTypes.Option[uint64]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) {
+								case 0:
+
+									option1490 = witTypes.None[uint64]()
+								case 1:
+
+									option1490 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))))
+								default:
+									panic("unreachable")
+								}
+								result1494 := make([]golem_api_context.Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))), index*(5*4))
+									value1491 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+									var variant1493 golem_api_context.AttributeValue
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+									case 0:
+										value1492 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+										variant1493 = golem_api_context.MakeAttributeValueString(value1492)
+
+									default:
+										panic("unreachable")
+									}
+
+									result1494 = append(result1494, golem_api_context.Attribute{value1491, variant1493})
+								}
+
+								variant1496 = MakeSpanDataLocalSpan(LocalSpanData{value1487, wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))}, option1489, option1490, result1494, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)})
+
+							case 1:
+								value1495 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant1496 = MakeSpanDataExternalSpan(ExternalSpanData{value1495})
+
+							default:
+								panic("unreachable")
+							}
+
+							result1497 = append(result1497, variant1496)
+						}
+
+						result1498 = append(result1498, result1497)
+					}
+
+					variant1502 = MakeAgentInvocationAgentMethodInvocation(AgentMethodInvocationParameters{value1278, value1279, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1455, result1459, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}, golem_core_types.SchemaValueTree{result1483, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4)))}}, value1484, result1486, result1498})
+
+				case 2:
+
+					variant1502 = MakeAgentInvocationSaveSnapshot()
+
+				case 3:
+					value1499 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+					value1500 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+
+					variant1502 = MakeAgentInvocationLoadSnapshot(LoadSnapshotParameters{SnapshotData{value1499, value1500}})
+
+				case 4:
+					value1501 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+
+					variant1502 = MakeAgentInvocationProcessOplogEntries(ProcessOplogEntriesParameters{value1501})
+
+				case 5:
+
+					variant1502 = MakeAgentInvocationManualUpdate(ManualUpdateParameters{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))})
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2693 = MakePublicOplogEntryAgentInvocationStarted(AgentInvocationStartedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, variant1502})
+
+			case 5:
+				var variant1917 AgentInvocationResult
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+				case 0:
+					result1678 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))), index*(56+22*4))
+						var variant1666 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option1509 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1509 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1504 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1504 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1503 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1503 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1503 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1503 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1504 = witTypes.Some[golem_core_types.NumericBound](variant1503)
+								default:
+									panic("unreachable")
+								}
+								var option1506 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1506 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1505 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1505 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1505 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1505 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1506 = witTypes.Some[golem_core_types.NumericBound](variant1505)
+								default:
+									panic("unreachable")
+								}
+								var option1508 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1508 = witTypes.None[string]()
+								case 1:
+									value1507 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1508 = witTypes.Some[string](value1507)
+								default:
+									panic("unreachable")
+								}
+
+								option1509 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1504, option1506, option1508})
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyS8Type(option1509)
+
+						case 3:
+							var option1516 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1516 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1511 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1511 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1510 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1510 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1510 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1510 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1511 = witTypes.Some[golem_core_types.NumericBound](variant1510)
+								default:
+									panic("unreachable")
+								}
+								var option1513 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1513 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1512 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1512 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1512 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1512 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1513 = witTypes.Some[golem_core_types.NumericBound](variant1512)
+								default:
+									panic("unreachable")
+								}
+								var option1515 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1515 = witTypes.None[string]()
+								case 1:
+									value1514 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1515 = witTypes.Some[string](value1514)
+								default:
+									panic("unreachable")
+								}
+
+								option1516 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1511, option1513, option1515})
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyS16Type(option1516)
+
+						case 4:
+							var option1523 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1523 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1518 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1518 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1517 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1517 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1517 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1517 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1518 = witTypes.Some[golem_core_types.NumericBound](variant1517)
+								default:
+									panic("unreachable")
+								}
+								var option1520 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1520 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1519 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1519 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1519 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1519 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1520 = witTypes.Some[golem_core_types.NumericBound](variant1519)
+								default:
+									panic("unreachable")
+								}
+								var option1522 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1522 = witTypes.None[string]()
+								case 1:
+									value1521 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1522 = witTypes.Some[string](value1521)
+								default:
+									panic("unreachable")
+								}
+
+								option1523 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1518, option1520, option1522})
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyS32Type(option1523)
+
+						case 5:
+							var option1530 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1530 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1525 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1525 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1524 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1524 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1524 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1524 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1525 = witTypes.Some[golem_core_types.NumericBound](variant1524)
+								default:
+									panic("unreachable")
+								}
+								var option1527 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1527 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1526 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1526 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1526 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1526 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1527 = witTypes.Some[golem_core_types.NumericBound](variant1526)
+								default:
+									panic("unreachable")
+								}
+								var option1529 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1529 = witTypes.None[string]()
+								case 1:
+									value1528 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1529 = witTypes.Some[string](value1528)
+								default:
+									panic("unreachable")
+								}
+
+								option1530 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1525, option1527, option1529})
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyS64Type(option1530)
+
+						case 6:
+							var option1537 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1537 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1532 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1532 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1531 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1531 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1531 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1531 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1532 = witTypes.Some[golem_core_types.NumericBound](variant1531)
+								default:
+									panic("unreachable")
+								}
+								var option1534 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1534 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1533 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1533 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1533 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1533 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1534 = witTypes.Some[golem_core_types.NumericBound](variant1533)
+								default:
+									panic("unreachable")
+								}
+								var option1536 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1536 = witTypes.None[string]()
+								case 1:
+									value1535 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1536 = witTypes.Some[string](value1535)
+								default:
+									panic("unreachable")
+								}
+
+								option1537 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1532, option1534, option1536})
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyU8Type(option1537)
+
+						case 7:
+							var option1544 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1544 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1539 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1539 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1538 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1538 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1538 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1538 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1539 = witTypes.Some[golem_core_types.NumericBound](variant1538)
+								default:
+									panic("unreachable")
+								}
+								var option1541 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1541 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1540 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1540 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1540 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1540 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1541 = witTypes.Some[golem_core_types.NumericBound](variant1540)
+								default:
+									panic("unreachable")
+								}
+								var option1543 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1543 = witTypes.None[string]()
+								case 1:
+									value1542 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1543 = witTypes.Some[string](value1542)
+								default:
+									panic("unreachable")
+								}
+
+								option1544 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1539, option1541, option1543})
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyU16Type(option1544)
+
+						case 8:
+							var option1551 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1551 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1546 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1546 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1545 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1545 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1545 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1545 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1546 = witTypes.Some[golem_core_types.NumericBound](variant1545)
+								default:
+									panic("unreachable")
+								}
+								var option1548 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1548 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1547 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1547 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1547 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1547 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1548 = witTypes.Some[golem_core_types.NumericBound](variant1547)
+								default:
+									panic("unreachable")
+								}
+								var option1550 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1550 = witTypes.None[string]()
+								case 1:
+									value1549 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1550 = witTypes.Some[string](value1549)
+								default:
+									panic("unreachable")
+								}
+
+								option1551 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1546, option1548, option1550})
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyU32Type(option1551)
+
+						case 9:
+							var option1558 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1558 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1553 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1553 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1552 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1552 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1552 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1552 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1553 = witTypes.Some[golem_core_types.NumericBound](variant1552)
+								default:
+									panic("unreachable")
+								}
+								var option1555 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1555 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1554 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1554 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1554 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1554 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1555 = witTypes.Some[golem_core_types.NumericBound](variant1554)
+								default:
+									panic("unreachable")
+								}
+								var option1557 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1557 = witTypes.None[string]()
+								case 1:
+									value1556 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1557 = witTypes.Some[string](value1556)
+								default:
+									panic("unreachable")
+								}
+
+								option1558 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1553, option1555, option1557})
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyU64Type(option1558)
+
+						case 10:
+							var option1565 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1565 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1560 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1560 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1559 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1559 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1559 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1559 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1560 = witTypes.Some[golem_core_types.NumericBound](variant1559)
+								default:
+									panic("unreachable")
+								}
+								var option1562 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1562 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1561 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1561 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1561 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1561 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1562 = witTypes.Some[golem_core_types.NumericBound](variant1561)
+								default:
+									panic("unreachable")
+								}
+								var option1564 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1564 = witTypes.None[string]()
+								case 1:
+									value1563 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1564 = witTypes.Some[string](value1563)
+								default:
+									panic("unreachable")
+								}
+
+								option1565 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1560, option1562, option1564})
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyF32Type(option1565)
+
+						case 11:
+							var option1572 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1572 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1567 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1567 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1566 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1566 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1566 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1566 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1567 = witTypes.Some[golem_core_types.NumericBound](variant1566)
+								default:
+									panic("unreachable")
+								}
+								var option1569 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1569 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1568 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1568 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1568 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1568 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1569 = witTypes.Some[golem_core_types.NumericBound](variant1568)
+								default:
+									panic("unreachable")
+								}
+								var option1571 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1571 = witTypes.None[string]()
+								case 1:
+									value1570 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1571 = witTypes.Some[string](value1570)
+								default:
+									panic("unreachable")
+								}
+
+								option1572 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1567, option1569, option1571})
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyF64Type(option1572)
+
+						case 12:
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result1585 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value1573 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1575 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option1575 = witTypes.None[string]()
+								case 1:
+									value1574 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option1575 = witTypes.Some[string](value1574)
+								default:
+									panic("unreachable")
+								}
+								result1577 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value1576 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1577 = append(result1577, value1576)
+								}
+
+								result1579 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value1578 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1579 = append(result1579, value1578)
+								}
+
+								var option1581 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option1581 = witTypes.None[string]()
+								case 1:
+									value1580 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option1581 = witTypes.Some[string](value1580)
+								default:
+									panic("unreachable")
+								}
+								var option1584 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option1584 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1583 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant1583 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1583 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1583 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1582 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant1583 = golem_core_types.MakeRoleOther(value1582)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1584 = witTypes.Some[golem_core_types.Role](variant1583)
+								default:
+									panic("unreachable")
+								}
+
+								result1585 = append(result1585, golem_core_types.NamedFieldType{value1573, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1575, result1577, result1579, option1581, option1584}})
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyRecordType(result1585)
+
+						case 15:
+							result1599 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value1586 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1587 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option1587 = witTypes.None[int32]()
+								case 1:
+
+									option1587 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option1589 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option1589 = witTypes.None[string]()
+								case 1:
+									value1588 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option1589 = witTypes.Some[string](value1588)
+								default:
+									panic("unreachable")
+								}
+								result1591 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1590 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1591 = append(result1591, value1590)
+								}
+
+								result1593 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value1592 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1593 = append(result1593, value1592)
+								}
+
+								var option1595 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option1595 = witTypes.None[string]()
+								case 1:
+									value1594 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option1595 = witTypes.Some[string](value1594)
+								default:
+									panic("unreachable")
+								}
+								var option1598 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option1598 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1597 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant1597 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1597 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1597 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1596 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant1597 = golem_core_types.MakeRoleOther(value1596)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1598 = witTypes.Some[golem_core_types.Role](variant1597)
+								default:
+									panic("unreachable")
+								}
+
+								result1599 = append(result1599, golem_core_types.VariantCaseType{value1586, option1587, golem_core_types.MetadataEnvelope{option1589, result1591, result1593, option1595, option1598}})
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyVariantType(result1599)
+
+						case 16:
+							result1601 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1600 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1601 = append(result1601, value1600)
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyEnumType(result1601)
+
+						case 17:
+							result1603 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1602 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1603 = append(result1603, value1602)
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1603)
+
+						case 18:
+							result1604 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1604 = append(result1604, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyTupleType(result1604)
+
+						case 19:
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option1605 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1605 = witTypes.None[int32]()
+							case 1:
+
+								option1605 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option1606 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option1606 = witTypes.None[int32]()
+							case 1:
+
+								option1606 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1605, option1606})
+
+						case 24:
+							var option1609 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1609 = witTypes.None[[]string]()
+							case 1:
+								result1608 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1607 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1608 = append(result1608, value1607)
+								}
+
+								option1609 = witTypes.Some[[]string](result1608)
+							default:
+								panic("unreachable")
+							}
+							var option1610 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1610 = witTypes.None[uint32]()
+							case 1:
+
+								option1610 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1611 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1611 = witTypes.None[uint32]()
+							case 1:
+
+								option1611 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1613 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option1613 = witTypes.None[string]()
+							case 1:
+								value1612 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option1613 = witTypes.Some[string](value1612)
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1609, option1610, option1611, option1613})
+
+						case 25:
+							var option1616 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1616 = witTypes.None[[]string]()
+							case 1:
+								result1615 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1614 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1615 = append(result1615, value1614)
+								}
+
+								option1616 = witTypes.Some[[]string](result1615)
+							default:
+								panic("unreachable")
+							}
+							var option1617 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1617 = witTypes.None[uint32]()
+							case 1:
+
+								option1617 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1618 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1618 = witTypes.None[uint32]()
+							case 1:
+
+								option1618 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1616, option1617, option1618})
+
+						case 26:
+							var option1621 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1621 = witTypes.None[[]string]()
+							case 1:
+								result1620 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value1619 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1620 = append(result1620, value1619)
+								}
+
+								option1621 = witTypes.Some[[]string](result1620)
+							default:
+								panic("unreachable")
+							}
+							var option1624 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1624 = witTypes.None[[]string]()
+							case 1:
+								result1623 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1622 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1623 = append(result1623, value1622)
+								}
+
+								option1624 = witTypes.Some[[]string](result1623)
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option1621, option1624})
+
+						case 27:
+							var option1627 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1627 = witTypes.None[[]string]()
+							case 1:
+								result1626 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1625 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1626 = append(result1626, value1625)
+								}
+
+								option1627 = witTypes.Some[[]string](result1626)
+							default:
+								panic("unreachable")
+							}
+							var option1630 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1630 = witTypes.None[[]string]()
+							case 1:
+								result1629 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value1628 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1629 = append(result1629, value1628)
+								}
+
+								option1630 = witTypes.Some[[]string](result1629)
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1627, option1630})
+
+						case 28:
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value1631 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result1633 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value1632 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1633 = append(result1633, value1632)
+							}
+
+							var option1635 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1635 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1634 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option1635 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value1634})
+							default:
+								panic("unreachable")
+							}
+							var option1637 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option1637 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1636 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option1637 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value1636})
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1631, result1633, option1635, option1637})
+
+						case 31:
+							result1659 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value1638 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant1647 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value1639 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1647 = golem_core_types.MakeDiscriminatorRulePrefix(value1639)
+
+								case 1:
+									value1640 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1647 = golem_core_types.MakeDiscriminatorRuleSuffix(value1640)
+
+								case 2:
+									value1641 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1647 = golem_core_types.MakeDiscriminatorRuleContains(value1641)
+
+								case 3:
+									value1642 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1647 = golem_core_types.MakeDiscriminatorRuleRegex(value1642)
+
+								case 4:
+									value1643 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option1645 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option1645 = witTypes.None[string]()
+									case 1:
+										value1644 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option1645 = witTypes.Some[string](value1644)
+									default:
+										panic("unreachable")
+									}
+
+									variant1647 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1643, option1645})
+
+								case 5:
+									value1646 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1647 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1646)
+
+								default:
+									panic("unreachable")
+								}
+								var option1649 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option1649 = witTypes.None[string]()
+								case 1:
+									value1648 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option1649 = witTypes.Some[string](value1648)
+								default:
+									panic("unreachable")
+								}
+								result1651 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value1650 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1651 = append(result1651, value1650)
+								}
+
+								result1653 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value1652 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1653 = append(result1653, value1652)
+								}
+
+								var option1655 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option1655 = witTypes.None[string]()
+								case 1:
+									value1654 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option1655 = witTypes.Some[string](value1654)
+								default:
+									panic("unreachable")
+								}
+								var option1658 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option1658 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1657 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant1657 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1657 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1657 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1656 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant1657 = golem_core_types.MakeRoleOther(value1656)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1658 = witTypes.Some[golem_core_types.Role](variant1657)
+								default:
+									panic("unreachable")
+								}
+
+								result1659 = append(result1659, golem_core_types.UnionBranch{value1638, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1647, golem_core_types.MetadataEnvelope{option1649, result1651, result1653, option1655, option1658}})
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1659})
+
+						case 32:
+							var option1661 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1661 = witTypes.None[string]()
+							case 1:
+								value1660 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option1661 = witTypes.Some[string](value1660)
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1661})
+
+						case 33:
+							var option1663 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1663 = witTypes.None[string]()
+							case 1:
+								value1662 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option1663 = witTypes.Some[string](value1662)
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1663})
+
+						case 34:
+							var option1664 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1664 = witTypes.None[int32]()
+							case 1:
+
+								option1664 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyFutureType(option1664)
+
+						case 35:
+							var option1665 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1665 = witTypes.None[int32]()
+							case 1:
+
+								option1665 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1666 = golem_core_types.MakeSchemaTypeBodyStreamType(option1665)
+
+						default:
+							panic("unreachable")
+						}
+						var option1668 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option1668 = witTypes.None[string]()
+						case 1:
+							value1667 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option1668 = witTypes.Some[string](value1667)
+						default:
+							panic("unreachable")
+						}
+						result1670 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value1669 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1670 = append(result1670, value1669)
+						}
+
+						result1672 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value1671 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1672 = append(result1672, value1671)
+						}
+
+						var option1674 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option1674 = witTypes.None[string]()
+						case 1:
+							value1673 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option1674 = witTypes.Some[string](value1673)
+						default:
+							panic("unreachable")
+						}
+						var option1677 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option1677 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant1676 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant1676 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant1676 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant1676 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value1675 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant1676 = golem_core_types.MakeRoleOther(value1675)
+
+							default:
+								panic("unreachable")
+							}
+
+							option1677 = witTypes.Some[golem_core_types.Role](variant1676)
+						default:
+							panic("unreachable")
+						}
+
+						result1678 = append(result1678, golem_core_types.SchemaTypeNode{variant1666, golem_core_types.MetadataEnvelope{option1668, result1670, result1672, option1674, option1677}})
+					}
+
+					result1682 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))))), index*(6*4))
+						value1679 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option1681 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option1681 = witTypes.None[string]()
+						case 1:
+							value1680 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option1681 = witTypes.Some[string](value1680)
+						default:
+							panic("unreachable")
+						}
+
+						result1682 = append(result1682, golem_core_types.SchemaTypeDef{value1679, option1681, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result1706 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))), index*(16+4*4))
+						var variant1705 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value1683 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeStringValue(value1683)
+
+						case 13:
+							result1684 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1684 = append(result1684, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeRecordValue(result1684)
+
+						case 14:
+							var option1685 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option1685 = witTypes.None[int32]()
+							case 1:
+
+								option1685 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1685})
+
+						case 15:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result1686 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result1686 = append(result1686, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1686)
+
+						case 17:
+							result1687 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1687 = append(result1687, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeTupleValue(result1687)
+
+						case 18:
+							result1688 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1688 = append(result1688, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeListValue(result1688)
+
+						case 19:
+							result1689 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1689 = append(result1689, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1689)
+
+						case 20:
+							result1690 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result1690 = append(result1690, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeMapValue(result1690)
+
+						case 21:
+							var option1691 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1691 = witTypes.None[int32]()
+							case 1:
+
+								option1691 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeOptionValue(option1691)
+
+						case 22:
+							var variant1694 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option1692 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1692 = witTypes.None[int32]()
+								case 1:
+
+									option1692 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1694 = golem_core_types.MakeResultValuePayloadOkValue(option1692)
+
+							case 1:
+								var option1693 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1693 = witTypes.None[int32]()
+								case 1:
+
+									option1693 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1694 = golem_core_types.MakeResultValuePayloadErrValue(option1693)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeResultValue(variant1694)
+
+						case 23:
+							value1695 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1697 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1697 = witTypes.None[string]()
+							case 1:
+								value1696 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1697 = witTypes.Some[string](value1696)
+							default:
+								panic("unreachable")
+							}
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1695, option1697})
+
+						case 24:
+							value1698 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1700 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1700 = witTypes.None[string]()
+							case 1:
+								value1699 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1700 = witTypes.Some[string](value1699)
+							default:
+								panic("unreachable")
+							}
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1698, option1700})
+
+						case 25:
+							value1701 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1705 = golem_core_types.MakeSchemaValueNodePathValue(value1701)
+
+						case 26:
+							value1702 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeUrlValue(value1702)
+
+						case 27:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value1703 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1703})
+
+						case 30:
+							value1704 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1704, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant1705 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result1706 = append(result1706, variant1705)
+					}
+
+					variant1917 = MakeAgentInvocationResultAgentInitialization(AgentInvocationOutputParameters{golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1678, result1682, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))}, golem_core_types.SchemaValueTree{result1706, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 8*4)))}}})
+
+				case 1:
+					result1882 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))), index*(56+22*4))
+						var variant1870 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option1713 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1713 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1708 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1708 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1707 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1707 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1707 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1707 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1708 = witTypes.Some[golem_core_types.NumericBound](variant1707)
+								default:
+									panic("unreachable")
+								}
+								var option1710 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1710 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1709 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1709 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1709 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1709 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1710 = witTypes.Some[golem_core_types.NumericBound](variant1709)
+								default:
+									panic("unreachable")
+								}
+								var option1712 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1712 = witTypes.None[string]()
+								case 1:
+									value1711 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1712 = witTypes.Some[string](value1711)
+								default:
+									panic("unreachable")
+								}
+
+								option1713 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1708, option1710, option1712})
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyS8Type(option1713)
+
+						case 3:
+							var option1720 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1720 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1715 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1715 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1714 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1714 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1714 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1714 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1715 = witTypes.Some[golem_core_types.NumericBound](variant1714)
+								default:
+									panic("unreachable")
+								}
+								var option1717 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1717 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1716 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1716 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1716 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1716 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1717 = witTypes.Some[golem_core_types.NumericBound](variant1716)
+								default:
+									panic("unreachable")
+								}
+								var option1719 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1719 = witTypes.None[string]()
+								case 1:
+									value1718 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1719 = witTypes.Some[string](value1718)
+								default:
+									panic("unreachable")
+								}
+
+								option1720 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1715, option1717, option1719})
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyS16Type(option1720)
+
+						case 4:
+							var option1727 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1727 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1722 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1722 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1721 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1721 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1721 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1721 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1722 = witTypes.Some[golem_core_types.NumericBound](variant1721)
+								default:
+									panic("unreachable")
+								}
+								var option1724 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1724 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1723 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1723 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1723 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1723 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1724 = witTypes.Some[golem_core_types.NumericBound](variant1723)
+								default:
+									panic("unreachable")
+								}
+								var option1726 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1726 = witTypes.None[string]()
+								case 1:
+									value1725 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1726 = witTypes.Some[string](value1725)
+								default:
+									panic("unreachable")
+								}
+
+								option1727 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1722, option1724, option1726})
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyS32Type(option1727)
+
+						case 5:
+							var option1734 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1734 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1729 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1729 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1728 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1728 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1728 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1728 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1729 = witTypes.Some[golem_core_types.NumericBound](variant1728)
+								default:
+									panic("unreachable")
+								}
+								var option1731 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1731 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1730 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1730 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1730 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1730 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1731 = witTypes.Some[golem_core_types.NumericBound](variant1730)
+								default:
+									panic("unreachable")
+								}
+								var option1733 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1733 = witTypes.None[string]()
+								case 1:
+									value1732 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1733 = witTypes.Some[string](value1732)
+								default:
+									panic("unreachable")
+								}
+
+								option1734 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1729, option1731, option1733})
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyS64Type(option1734)
+
+						case 6:
+							var option1741 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1741 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1736 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1736 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1735 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1735 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1735 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1735 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1736 = witTypes.Some[golem_core_types.NumericBound](variant1735)
+								default:
+									panic("unreachable")
+								}
+								var option1738 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1738 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1737 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1737 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1737 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1737 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1738 = witTypes.Some[golem_core_types.NumericBound](variant1737)
+								default:
+									panic("unreachable")
+								}
+								var option1740 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1740 = witTypes.None[string]()
+								case 1:
+									value1739 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1740 = witTypes.Some[string](value1739)
+								default:
+									panic("unreachable")
+								}
+
+								option1741 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1736, option1738, option1740})
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyU8Type(option1741)
+
+						case 7:
+							var option1748 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1748 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1743 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1743 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1742 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1742 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1742 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1742 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1743 = witTypes.Some[golem_core_types.NumericBound](variant1742)
+								default:
+									panic("unreachable")
+								}
+								var option1745 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1745 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1744 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1744 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1744 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1744 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1745 = witTypes.Some[golem_core_types.NumericBound](variant1744)
+								default:
+									panic("unreachable")
+								}
+								var option1747 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1747 = witTypes.None[string]()
+								case 1:
+									value1746 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1747 = witTypes.Some[string](value1746)
+								default:
+									panic("unreachable")
+								}
+
+								option1748 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1743, option1745, option1747})
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyU16Type(option1748)
+
+						case 8:
+							var option1755 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1755 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1750 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1750 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1749 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1749 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1749 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1749 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1750 = witTypes.Some[golem_core_types.NumericBound](variant1749)
+								default:
+									panic("unreachable")
+								}
+								var option1752 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1752 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1751 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1751 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1751 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1751 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1752 = witTypes.Some[golem_core_types.NumericBound](variant1751)
+								default:
+									panic("unreachable")
+								}
+								var option1754 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1754 = witTypes.None[string]()
+								case 1:
+									value1753 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1754 = witTypes.Some[string](value1753)
+								default:
+									panic("unreachable")
+								}
+
+								option1755 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1750, option1752, option1754})
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyU32Type(option1755)
+
+						case 9:
+							var option1762 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1762 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1757 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1757 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1756 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1756 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1756 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1756 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1757 = witTypes.Some[golem_core_types.NumericBound](variant1756)
+								default:
+									panic("unreachable")
+								}
+								var option1759 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1759 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1758 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1758 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1758 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1758 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1759 = witTypes.Some[golem_core_types.NumericBound](variant1758)
+								default:
+									panic("unreachable")
+								}
+								var option1761 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1761 = witTypes.None[string]()
+								case 1:
+									value1760 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1761 = witTypes.Some[string](value1760)
+								default:
+									panic("unreachable")
+								}
+
+								option1762 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1757, option1759, option1761})
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyU64Type(option1762)
+
+						case 10:
+							var option1769 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1769 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1764 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1764 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1763 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1763 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1763 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1763 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1764 = witTypes.Some[golem_core_types.NumericBound](variant1763)
+								default:
+									panic("unreachable")
+								}
+								var option1766 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1766 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1765 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1765 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1765 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1765 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1766 = witTypes.Some[golem_core_types.NumericBound](variant1765)
+								default:
+									panic("unreachable")
+								}
+								var option1768 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1768 = witTypes.None[string]()
+								case 1:
+									value1767 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1768 = witTypes.Some[string](value1767)
+								default:
+									panic("unreachable")
+								}
+
+								option1769 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1764, option1766, option1768})
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyF32Type(option1769)
+
+						case 11:
+							var option1776 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1776 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1771 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1771 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1770 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1770 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1770 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1770 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1771 = witTypes.Some[golem_core_types.NumericBound](variant1770)
+								default:
+									panic("unreachable")
+								}
+								var option1773 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1773 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1772 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1772 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1772 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1772 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1773 = witTypes.Some[golem_core_types.NumericBound](variant1772)
+								default:
+									panic("unreachable")
+								}
+								var option1775 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1775 = witTypes.None[string]()
+								case 1:
+									value1774 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1775 = witTypes.Some[string](value1774)
+								default:
+									panic("unreachable")
+								}
+
+								option1776 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1771, option1773, option1775})
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyF64Type(option1776)
+
+						case 12:
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result1789 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value1777 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1779 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option1779 = witTypes.None[string]()
+								case 1:
+									value1778 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option1779 = witTypes.Some[string](value1778)
+								default:
+									panic("unreachable")
+								}
+								result1781 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value1780 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1781 = append(result1781, value1780)
+								}
+
+								result1783 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value1782 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1783 = append(result1783, value1782)
+								}
+
+								var option1785 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option1785 = witTypes.None[string]()
+								case 1:
+									value1784 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option1785 = witTypes.Some[string](value1784)
+								default:
+									panic("unreachable")
+								}
+								var option1788 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option1788 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1787 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant1787 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1787 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1787 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1786 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant1787 = golem_core_types.MakeRoleOther(value1786)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1788 = witTypes.Some[golem_core_types.Role](variant1787)
+								default:
+									panic("unreachable")
+								}
+
+								result1789 = append(result1789, golem_core_types.NamedFieldType{value1777, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1779, result1781, result1783, option1785, option1788}})
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyRecordType(result1789)
+
+						case 15:
+							result1803 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value1790 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1791 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option1791 = witTypes.None[int32]()
+								case 1:
+
+									option1791 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option1793 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option1793 = witTypes.None[string]()
+								case 1:
+									value1792 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option1793 = witTypes.Some[string](value1792)
+								default:
+									panic("unreachable")
+								}
+								result1795 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1794 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1795 = append(result1795, value1794)
+								}
+
+								result1797 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value1796 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1797 = append(result1797, value1796)
+								}
+
+								var option1799 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option1799 = witTypes.None[string]()
+								case 1:
+									value1798 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option1799 = witTypes.Some[string](value1798)
+								default:
+									panic("unreachable")
+								}
+								var option1802 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option1802 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1801 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant1801 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1801 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1801 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1800 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant1801 = golem_core_types.MakeRoleOther(value1800)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1802 = witTypes.Some[golem_core_types.Role](variant1801)
+								default:
+									panic("unreachable")
+								}
+
+								result1803 = append(result1803, golem_core_types.VariantCaseType{value1790, option1791, golem_core_types.MetadataEnvelope{option1793, result1795, result1797, option1799, option1802}})
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyVariantType(result1803)
+
+						case 16:
+							result1805 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1804 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1805 = append(result1805, value1804)
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyEnumType(result1805)
+
+						case 17:
+							result1807 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1806 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1807 = append(result1807, value1806)
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1807)
+
+						case 18:
+							result1808 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1808 = append(result1808, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyTupleType(result1808)
+
+						case 19:
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option1809 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1809 = witTypes.None[int32]()
+							case 1:
+
+								option1809 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option1810 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option1810 = witTypes.None[int32]()
+							case 1:
+
+								option1810 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1809, option1810})
+
+						case 24:
+							var option1813 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1813 = witTypes.None[[]string]()
+							case 1:
+								result1812 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1811 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1812 = append(result1812, value1811)
+								}
+
+								option1813 = witTypes.Some[[]string](result1812)
+							default:
+								panic("unreachable")
+							}
+							var option1814 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1814 = witTypes.None[uint32]()
+							case 1:
+
+								option1814 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1815 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1815 = witTypes.None[uint32]()
+							case 1:
+
+								option1815 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1817 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option1817 = witTypes.None[string]()
+							case 1:
+								value1816 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option1817 = witTypes.Some[string](value1816)
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1813, option1814, option1815, option1817})
+
+						case 25:
+							var option1820 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1820 = witTypes.None[[]string]()
+							case 1:
+								result1819 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1818 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1819 = append(result1819, value1818)
+								}
+
+								option1820 = witTypes.Some[[]string](result1819)
+							default:
+								panic("unreachable")
+							}
+							var option1821 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1821 = witTypes.None[uint32]()
+							case 1:
+
+								option1821 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1822 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1822 = witTypes.None[uint32]()
+							case 1:
+
+								option1822 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1820, option1821, option1822})
+
+						case 26:
+							var option1825 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1825 = witTypes.None[[]string]()
+							case 1:
+								result1824 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value1823 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1824 = append(result1824, value1823)
+								}
+
+								option1825 = witTypes.Some[[]string](result1824)
+							default:
+								panic("unreachable")
+							}
+							var option1828 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1828 = witTypes.None[[]string]()
+							case 1:
+								result1827 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1826 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1827 = append(result1827, value1826)
+								}
+
+								option1828 = witTypes.Some[[]string](result1827)
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option1825, option1828})
+
+						case 27:
+							var option1831 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1831 = witTypes.None[[]string]()
+							case 1:
+								result1830 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1829 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1830 = append(result1830, value1829)
+								}
+
+								option1831 = witTypes.Some[[]string](result1830)
+							default:
+								panic("unreachable")
+							}
+							var option1834 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1834 = witTypes.None[[]string]()
+							case 1:
+								result1833 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value1832 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1833 = append(result1833, value1832)
+								}
+
+								option1834 = witTypes.Some[[]string](result1833)
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1831, option1834})
+
+						case 28:
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value1835 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result1837 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value1836 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1837 = append(result1837, value1836)
+							}
+
+							var option1839 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1839 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1838 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option1839 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value1838})
+							default:
+								panic("unreachable")
+							}
+							var option1841 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option1841 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1840 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option1841 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value1840})
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1835, result1837, option1839, option1841})
+
+						case 31:
+							result1863 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value1842 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant1851 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value1843 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1851 = golem_core_types.MakeDiscriminatorRulePrefix(value1843)
+
+								case 1:
+									value1844 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1851 = golem_core_types.MakeDiscriminatorRuleSuffix(value1844)
+
+								case 2:
+									value1845 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1851 = golem_core_types.MakeDiscriminatorRuleContains(value1845)
+
+								case 3:
+									value1846 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1851 = golem_core_types.MakeDiscriminatorRuleRegex(value1846)
+
+								case 4:
+									value1847 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option1849 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option1849 = witTypes.None[string]()
+									case 1:
+										value1848 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option1849 = witTypes.Some[string](value1848)
+									default:
+										panic("unreachable")
+									}
+
+									variant1851 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1847, option1849})
+
+								case 5:
+									value1850 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1851 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1850)
+
+								default:
+									panic("unreachable")
+								}
+								var option1853 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option1853 = witTypes.None[string]()
+								case 1:
+									value1852 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option1853 = witTypes.Some[string](value1852)
+								default:
+									panic("unreachable")
+								}
+								result1855 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value1854 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1855 = append(result1855, value1854)
+								}
+
+								result1857 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value1856 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1857 = append(result1857, value1856)
+								}
+
+								var option1859 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option1859 = witTypes.None[string]()
+								case 1:
+									value1858 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option1859 = witTypes.Some[string](value1858)
+								default:
+									panic("unreachable")
+								}
+								var option1862 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option1862 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1861 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant1861 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1861 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1861 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1860 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant1861 = golem_core_types.MakeRoleOther(value1860)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1862 = witTypes.Some[golem_core_types.Role](variant1861)
+								default:
+									panic("unreachable")
+								}
+
+								result1863 = append(result1863, golem_core_types.UnionBranch{value1842, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1851, golem_core_types.MetadataEnvelope{option1853, result1855, result1857, option1859, option1862}})
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1863})
+
+						case 32:
+							var option1865 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1865 = witTypes.None[string]()
+							case 1:
+								value1864 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option1865 = witTypes.Some[string](value1864)
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1865})
+
+						case 33:
+							var option1867 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1867 = witTypes.None[string]()
+							case 1:
+								value1866 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option1867 = witTypes.Some[string](value1866)
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1867})
+
+						case 34:
+							var option1868 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1868 = witTypes.None[int32]()
+							case 1:
+
+								option1868 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyFutureType(option1868)
+
+						case 35:
+							var option1869 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1869 = witTypes.None[int32]()
+							case 1:
+
+								option1869 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1870 = golem_core_types.MakeSchemaTypeBodyStreamType(option1869)
+
+						default:
+							panic("unreachable")
+						}
+						var option1872 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option1872 = witTypes.None[string]()
+						case 1:
+							value1871 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option1872 = witTypes.Some[string](value1871)
+						default:
+							panic("unreachable")
+						}
+						result1874 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value1873 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1874 = append(result1874, value1873)
+						}
+
+						result1876 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value1875 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1876 = append(result1876, value1875)
+						}
+
+						var option1878 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option1878 = witTypes.None[string]()
+						case 1:
+							value1877 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option1878 = witTypes.Some[string](value1877)
+						default:
+							panic("unreachable")
+						}
+						var option1881 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option1881 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant1880 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant1880 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant1880 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant1880 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value1879 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant1880 = golem_core_types.MakeRoleOther(value1879)
+
+							default:
+								panic("unreachable")
+							}
+
+							option1881 = witTypes.Some[golem_core_types.Role](variant1880)
+						default:
+							panic("unreachable")
+						}
+
+						result1882 = append(result1882, golem_core_types.SchemaTypeNode{variant1870, golem_core_types.MetadataEnvelope{option1872, result1874, result1876, option1878, option1881}})
+					}
+
+					result1886 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))))), index*(6*4))
+						value1883 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option1885 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option1885 = witTypes.None[string]()
+						case 1:
+							value1884 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option1885 = witTypes.Some[string](value1884)
+						default:
+							panic("unreachable")
+						}
+
+						result1886 = append(result1886, golem_core_types.SchemaTypeDef{value1883, option1885, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result1910 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))), index*(16+4*4))
+						var variant1909 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value1887 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeStringValue(value1887)
+
+						case 13:
+							result1888 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1888 = append(result1888, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeRecordValue(result1888)
+
+						case 14:
+							var option1889 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option1889 = witTypes.None[int32]()
+							case 1:
+
+								option1889 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1889})
+
+						case 15:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result1890 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result1890 = append(result1890, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1890)
+
+						case 17:
+							result1891 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1891 = append(result1891, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeTupleValue(result1891)
+
+						case 18:
+							result1892 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1892 = append(result1892, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeListValue(result1892)
+
+						case 19:
+							result1893 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1893 = append(result1893, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1893)
+
+						case 20:
+							result1894 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result1894 = append(result1894, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeMapValue(result1894)
+
+						case 21:
+							var option1895 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1895 = witTypes.None[int32]()
+							case 1:
+
+								option1895 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeOptionValue(option1895)
+
+						case 22:
+							var variant1898 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option1896 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1896 = witTypes.None[int32]()
+								case 1:
+
+									option1896 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1898 = golem_core_types.MakeResultValuePayloadOkValue(option1896)
+
+							case 1:
+								var option1897 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1897 = witTypes.None[int32]()
+								case 1:
+
+									option1897 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1898 = golem_core_types.MakeResultValuePayloadErrValue(option1897)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeResultValue(variant1898)
+
+						case 23:
+							value1899 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1901 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1901 = witTypes.None[string]()
+							case 1:
+								value1900 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1901 = witTypes.Some[string](value1900)
+							default:
+								panic("unreachable")
+							}
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1899, option1901})
+
+						case 24:
+							value1902 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1904 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1904 = witTypes.None[string]()
+							case 1:
+								value1903 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1904 = witTypes.Some[string](value1903)
+							default:
+								panic("unreachable")
+							}
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1902, option1904})
+
+						case 25:
+							value1905 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1909 = golem_core_types.MakeSchemaValueNodePathValue(value1905)
+
+						case 26:
+							value1906 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeUrlValue(value1906)
+
+						case 27:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value1907 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1907})
+
+						case 30:
+							value1908 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1908, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant1909 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result1910 = append(result1910, variant1909)
+					}
+
+					variant1917 = MakeAgentInvocationResultAgentMethod(AgentInvocationOutputParameters{golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1882, result1886, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))}, golem_core_types.SchemaValueTree{result1910, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 8*4)))}}})
+
+				case 2:
+
+					variant1917 = MakeAgentInvocationResultManualUpdate()
+
+				case 3:
+					var option1912 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) {
+					case 0:
+
+						option1912 = witTypes.None[string]()
+					case 1:
+						value1911 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))))
+
+						option1912 = witTypes.Some[string](value1911)
+					default:
+						panic("unreachable")
+					}
+
+					variant1917 = MakeAgentInvocationResultLoadSnapshot(FallibleResultParameters{option1912})
+
+				case 4:
+					value1913 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4))))
+					value1914 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+					variant1917 = MakeAgentInvocationResultSaveSnapshot(SaveSnapshotResultParameters{SnapshotData{value1913, value1914}})
+
+				case 5:
+					var option1916 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) {
+					case 0:
+
+						option1916 = witTypes.None[string]()
+					case 1:
+						value1915 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))))
+
+						option1916 = witTypes.Some[string](value1915)
+					default:
+						panic("unreachable")
+					}
+
+					variant1917 = MakeAgentInvocationResultProcessOplogEntries(FallibleResultParameters{option1916})
+
+				default:
+					panic("unreachable")
+				}
+				var option1919 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 9*4)))) {
+				case 0:
+
+					option1919 = witTypes.None[string]()
+				case 1:
+					value1918 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 11*4))))
+
+					option1919 = witTypes.Some[string](value1918)
+				default:
+					panic("unreachable")
+				}
+
+				variant2693 = MakePublicOplogEntryAgentInvocationFinished(AgentInvocationFinishedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, variant1917, option1919, *(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 12*4))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))))})
+
+			case 6:
+
+				variant2693 = MakePublicOplogEntrySuspend(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}})
+
+			case 7:
+				value1920 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+				var option1923 witTypes.Option[RetryPolicyState]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) {
+				case 0:
+
+					option1923 = witTypes.None[RetryPolicyState]()
+				case 1:
+					result1922 := make([]StateNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))), index*16)
+						var variant1921 StateNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1921 = MakeStateNodeCounter(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4))))
+
+						case 1:
+
+							variant1921 = MakeStateNodeTerminal()
+
+						case 2:
+
+							variant1921 = MakeStateNodeWrapper(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						case 3:
+
+							variant1921 = MakeStateNodeCountBox(CountBoxState{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 4:
+
+							variant1921 = MakeStateNodeAndThen(AndThenState{*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) != 0)})
+
+						case 5:
+
+							variant1921 = MakeStateNodePair(PairState{*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						default:
+							panic("unreachable")
+						}
+
+						result1922 = append(result1922, variant1921)
+					}
+
+					option1923 = witTypes.Some[RetryPolicyState](RetryPolicyState{result1922})
+				default:
+					panic("unreachable")
+				}
+
+				variant2693 = MakePublicOplogEntryError(ErrorParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, value1920, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))) != 0), option1923})
+
+			case 8:
+
+				variant2693 = MakePublicOplogEntryNoOp(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}})
+
+			case 9:
+
+				variant2693 = MakePublicOplogEntryJump(JumpParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, OplogRegion{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}})
+
+			case 10:
+
+				variant2693 = MakePublicOplogEntryInterrupted(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}})
+
+			case 11:
+
+				variant2693 = MakePublicOplogEntryExited(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}})
+
+			case 12:
+
+				variant2693 = MakePublicOplogEntryBeginAtomicRegion(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}})
+
+			case 13:
+
+				variant2693 = MakePublicOplogEntryEndAtomicRegion(EndAtomicRegionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24)))})
+
+			case 14:
+				var variant2368 AgentInvocation
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+				case 0:
+					value1924 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+					result2100 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))), index*(56+22*4))
+						var variant2088 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option1931 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1931 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1926 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1926 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1925 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1925 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1925 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1925 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1926 = witTypes.Some[golem_core_types.NumericBound](variant1925)
+								default:
+									panic("unreachable")
+								}
+								var option1928 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1928 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1927 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1927 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1927 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1927 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1928 = witTypes.Some[golem_core_types.NumericBound](variant1927)
+								default:
+									panic("unreachable")
+								}
+								var option1930 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1930 = witTypes.None[string]()
+								case 1:
+									value1929 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1930 = witTypes.Some[string](value1929)
+								default:
+									panic("unreachable")
+								}
+
+								option1931 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1926, option1928, option1930})
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyS8Type(option1931)
+
+						case 3:
+							var option1938 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1938 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1933 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1933 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1932 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1932 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1932 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1932 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1933 = witTypes.Some[golem_core_types.NumericBound](variant1932)
+								default:
+									panic("unreachable")
+								}
+								var option1935 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1935 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1934 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1934 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1934 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1934 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1935 = witTypes.Some[golem_core_types.NumericBound](variant1934)
+								default:
+									panic("unreachable")
+								}
+								var option1937 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1937 = witTypes.None[string]()
+								case 1:
+									value1936 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1937 = witTypes.Some[string](value1936)
+								default:
+									panic("unreachable")
+								}
+
+								option1938 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1933, option1935, option1937})
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyS16Type(option1938)
+
+						case 4:
+							var option1945 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1945 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1940 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1940 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1939 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1939 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1939 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1939 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1940 = witTypes.Some[golem_core_types.NumericBound](variant1939)
+								default:
+									panic("unreachable")
+								}
+								var option1942 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1942 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1941 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1941 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1941 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1941 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1942 = witTypes.Some[golem_core_types.NumericBound](variant1941)
+								default:
+									panic("unreachable")
+								}
+								var option1944 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1944 = witTypes.None[string]()
+								case 1:
+									value1943 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1944 = witTypes.Some[string](value1943)
+								default:
+									panic("unreachable")
+								}
+
+								option1945 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1940, option1942, option1944})
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyS32Type(option1945)
+
+						case 5:
+							var option1952 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1952 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1947 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1947 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1946 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1946 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1946 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1946 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1947 = witTypes.Some[golem_core_types.NumericBound](variant1946)
+								default:
+									panic("unreachable")
+								}
+								var option1949 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1949 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1948 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1948 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1948 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1948 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1949 = witTypes.Some[golem_core_types.NumericBound](variant1948)
+								default:
+									panic("unreachable")
+								}
+								var option1951 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1951 = witTypes.None[string]()
+								case 1:
+									value1950 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1951 = witTypes.Some[string](value1950)
+								default:
+									panic("unreachable")
+								}
+
+								option1952 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1947, option1949, option1951})
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyS64Type(option1952)
+
+						case 6:
+							var option1959 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1959 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1954 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1954 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1953 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1953 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1953 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1953 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1954 = witTypes.Some[golem_core_types.NumericBound](variant1953)
+								default:
+									panic("unreachable")
+								}
+								var option1956 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1956 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1955 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1955 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1955 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1955 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1956 = witTypes.Some[golem_core_types.NumericBound](variant1955)
+								default:
+									panic("unreachable")
+								}
+								var option1958 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1958 = witTypes.None[string]()
+								case 1:
+									value1957 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1958 = witTypes.Some[string](value1957)
+								default:
+									panic("unreachable")
+								}
+
+								option1959 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1954, option1956, option1958})
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyU8Type(option1959)
+
+						case 7:
+							var option1966 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1966 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1961 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1961 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1960 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1960 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1960 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1960 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1961 = witTypes.Some[golem_core_types.NumericBound](variant1960)
+								default:
+									panic("unreachable")
+								}
+								var option1963 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1963 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1962 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1962 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1962 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1962 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1963 = witTypes.Some[golem_core_types.NumericBound](variant1962)
+								default:
+									panic("unreachable")
+								}
+								var option1965 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1965 = witTypes.None[string]()
+								case 1:
+									value1964 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1965 = witTypes.Some[string](value1964)
+								default:
+									panic("unreachable")
+								}
+
+								option1966 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1961, option1963, option1965})
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyU16Type(option1966)
+
+						case 8:
+							var option1973 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1973 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1968 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1968 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1967 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1967 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1967 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1967 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1968 = witTypes.Some[golem_core_types.NumericBound](variant1967)
+								default:
+									panic("unreachable")
+								}
+								var option1970 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1970 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1969 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1969 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1969 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1969 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1970 = witTypes.Some[golem_core_types.NumericBound](variant1969)
+								default:
+									panic("unreachable")
+								}
+								var option1972 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1972 = witTypes.None[string]()
+								case 1:
+									value1971 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1972 = witTypes.Some[string](value1971)
+								default:
+									panic("unreachable")
+								}
+
+								option1973 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1968, option1970, option1972})
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyU32Type(option1973)
+
+						case 9:
+							var option1980 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1980 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1975 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1975 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1974 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1974 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1974 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1974 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1975 = witTypes.Some[golem_core_types.NumericBound](variant1974)
+								default:
+									panic("unreachable")
+								}
+								var option1977 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1977 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1976 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1976 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1976 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1976 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1977 = witTypes.Some[golem_core_types.NumericBound](variant1976)
+								default:
+									panic("unreachable")
+								}
+								var option1979 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1979 = witTypes.None[string]()
+								case 1:
+									value1978 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1979 = witTypes.Some[string](value1978)
+								default:
+									panic("unreachable")
+								}
+
+								option1980 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1975, option1977, option1979})
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyU64Type(option1980)
+
+						case 10:
+							var option1987 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1987 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1982 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1982 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1981 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1981 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1981 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1981 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1982 = witTypes.Some[golem_core_types.NumericBound](variant1981)
+								default:
+									panic("unreachable")
+								}
+								var option1984 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1984 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1983 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1983 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1983 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1983 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1984 = witTypes.Some[golem_core_types.NumericBound](variant1983)
+								default:
+									panic("unreachable")
+								}
+								var option1986 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1986 = witTypes.None[string]()
+								case 1:
+									value1985 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1986 = witTypes.Some[string](value1985)
+								default:
+									panic("unreachable")
+								}
+
+								option1987 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1982, option1984, option1986})
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyF32Type(option1987)
+
+						case 11:
+							var option1994 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1994 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1989 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1989 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1988 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1988 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1988 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1988 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1989 = witTypes.Some[golem_core_types.NumericBound](variant1988)
+								default:
+									panic("unreachable")
+								}
+								var option1991 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1991 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1990 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1990 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1990 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1990 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1991 = witTypes.Some[golem_core_types.NumericBound](variant1990)
+								default:
+									panic("unreachable")
+								}
+								var option1993 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1993 = witTypes.None[string]()
+								case 1:
+									value1992 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1993 = witTypes.Some[string](value1992)
+								default:
+									panic("unreachable")
+								}
+
+								option1994 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1989, option1991, option1993})
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyF64Type(option1994)
+
+						case 12:
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result2007 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value1995 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1997 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option1997 = witTypes.None[string]()
+								case 1:
+									value1996 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option1997 = witTypes.Some[string](value1996)
+								default:
+									panic("unreachable")
+								}
+								result1999 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value1998 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1999 = append(result1999, value1998)
+								}
+
+								result2001 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value2000 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2001 = append(result2001, value2000)
+								}
+
+								var option2003 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option2003 = witTypes.None[string]()
+								case 1:
+									value2002 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option2003 = witTypes.Some[string](value2002)
+								default:
+									panic("unreachable")
+								}
+								var option2006 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option2006 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant2005 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant2005 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant2005 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant2005 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value2004 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant2005 = golem_core_types.MakeRoleOther(value2004)
+
+									default:
+										panic("unreachable")
+									}
+
+									option2006 = witTypes.Some[golem_core_types.Role](variant2005)
+								default:
+									panic("unreachable")
+								}
+
+								result2007 = append(result2007, golem_core_types.NamedFieldType{value1995, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1997, result1999, result2001, option2003, option2006}})
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyRecordType(result2007)
+
+						case 15:
+							result2021 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value2008 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option2009 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option2009 = witTypes.None[int32]()
+								case 1:
+
+									option2009 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option2011 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option2011 = witTypes.None[string]()
+								case 1:
+									value2010 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option2011 = witTypes.Some[string](value2010)
+								default:
+									panic("unreachable")
+								}
+								result2013 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value2012 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2013 = append(result2013, value2012)
+								}
+
+								result2015 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value2014 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2015 = append(result2015, value2014)
+								}
+
+								var option2017 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option2017 = witTypes.None[string]()
+								case 1:
+									value2016 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option2017 = witTypes.Some[string](value2016)
+								default:
+									panic("unreachable")
+								}
+								var option2020 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option2020 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant2019 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant2019 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant2019 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant2019 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value2018 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant2019 = golem_core_types.MakeRoleOther(value2018)
+
+									default:
+										panic("unreachable")
+									}
+
+									option2020 = witTypes.Some[golem_core_types.Role](variant2019)
+								default:
+									panic("unreachable")
+								}
+
+								result2021 = append(result2021, golem_core_types.VariantCaseType{value2008, option2009, golem_core_types.MetadataEnvelope{option2011, result2013, result2015, option2017, option2020}})
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyVariantType(result2021)
+
+						case 16:
+							result2023 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value2022 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2023 = append(result2023, value2022)
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyEnumType(result2023)
+
+						case 17:
+							result2025 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value2024 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2025 = append(result2025, value2024)
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyFlagsType(result2025)
+
+						case 18:
+							result2026 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2026 = append(result2026, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyTupleType(result2026)
+
+						case 19:
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option2027 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2027 = witTypes.None[int32]()
+							case 1:
+
+								option2027 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option2028 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2028 = witTypes.None[int32]()
+							case 1:
+
+								option2028 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option2027, option2028})
+
+						case 24:
+							var option2031 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2031 = witTypes.None[[]string]()
+							case 1:
+								result2030 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value2029 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2030 = append(result2030, value2029)
+								}
+
+								option2031 = witTypes.Some[[]string](result2030)
+							default:
+								panic("unreachable")
+							}
+							var option2032 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option2032 = witTypes.None[uint32]()
+							case 1:
+
+								option2032 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option2033 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option2033 = witTypes.None[uint32]()
+							case 1:
+
+								option2033 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option2035 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option2035 = witTypes.None[string]()
+							case 1:
+								value2034 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option2035 = witTypes.Some[string](value2034)
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option2031, option2032, option2033, option2035})
+
+						case 25:
+							var option2038 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2038 = witTypes.None[[]string]()
+							case 1:
+								result2037 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value2036 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2037 = append(result2037, value2036)
+								}
+
+								option2038 = witTypes.Some[[]string](result2037)
+							default:
+								panic("unreachable")
+							}
+							var option2039 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option2039 = witTypes.None[uint32]()
+							case 1:
+
+								option2039 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option2040 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option2040 = witTypes.None[uint32]()
+							case 1:
+
+								option2040 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option2038, option2039, option2040})
+
+						case 26:
+							var option2043 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option2043 = witTypes.None[[]string]()
+							case 1:
+								result2042 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value2041 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2042 = append(result2042, value2041)
+								}
+
+								option2043 = witTypes.Some[[]string](result2042)
+							default:
+								panic("unreachable")
+							}
+							var option2046 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option2046 = witTypes.None[[]string]()
+							case 1:
+								result2045 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value2044 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2045 = append(result2045, value2044)
+								}
+
+								option2046 = witTypes.Some[[]string](result2045)
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option2043, option2046})
+
+						case 27:
+							var option2049 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2049 = witTypes.None[[]string]()
+							case 1:
+								result2048 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value2047 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2048 = append(result2048, value2047)
+								}
+
+								option2049 = witTypes.Some[[]string](result2048)
+							default:
+								panic("unreachable")
+							}
+							var option2052 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option2052 = witTypes.None[[]string]()
+							case 1:
+								result2051 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value2050 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2051 = append(result2051, value2050)
+								}
+
+								option2052 = witTypes.Some[[]string](result2051)
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option2049, option2052})
+
+						case 28:
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value2053 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result2055 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value2054 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2055 = append(result2055, value2054)
+							}
+
+							var option2057 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option2057 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value2056 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option2057 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value2056})
+							default:
+								panic("unreachable")
+							}
+							var option2059 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option2059 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value2058 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option2059 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value2058})
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value2053, result2055, option2057, option2059})
+
+						case 31:
+							result2081 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value2060 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant2069 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value2061 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2069 = golem_core_types.MakeDiscriminatorRulePrefix(value2061)
+
+								case 1:
+									value2062 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2069 = golem_core_types.MakeDiscriminatorRuleSuffix(value2062)
+
+								case 2:
+									value2063 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2069 = golem_core_types.MakeDiscriminatorRuleContains(value2063)
+
+								case 3:
+									value2064 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2069 = golem_core_types.MakeDiscriminatorRuleRegex(value2064)
+
+								case 4:
+									value2065 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option2067 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option2067 = witTypes.None[string]()
+									case 1:
+										value2066 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option2067 = witTypes.Some[string](value2066)
+									default:
+										panic("unreachable")
+									}
+
+									variant2069 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value2065, option2067})
+
+								case 5:
+									value2068 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2069 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value2068)
+
+								default:
+									panic("unreachable")
+								}
+								var option2071 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option2071 = witTypes.None[string]()
+								case 1:
+									value2070 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option2071 = witTypes.Some[string](value2070)
+								default:
+									panic("unreachable")
+								}
+								result2073 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value2072 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2073 = append(result2073, value2072)
+								}
+
+								result2075 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value2074 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2075 = append(result2075, value2074)
+								}
+
+								var option2077 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option2077 = witTypes.None[string]()
+								case 1:
+									value2076 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option2077 = witTypes.Some[string](value2076)
+								default:
+									panic("unreachable")
+								}
+								var option2080 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option2080 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant2079 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant2079 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant2079 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant2079 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value2078 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant2079 = golem_core_types.MakeRoleOther(value2078)
+
+									default:
+										panic("unreachable")
+									}
+
+									option2080 = witTypes.Some[golem_core_types.Role](variant2079)
+								default:
+									panic("unreachable")
+								}
+
+								result2081 = append(result2081, golem_core_types.UnionBranch{value2060, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant2069, golem_core_types.MetadataEnvelope{option2071, result2073, result2075, option2077, option2080}})
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result2081})
+
+						case 32:
+							var option2083 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option2083 = witTypes.None[string]()
+							case 1:
+								value2082 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option2083 = witTypes.Some[string](value2082)
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option2083})
+
+						case 33:
+							var option2085 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2085 = witTypes.None[string]()
+							case 1:
+								value2084 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option2085 = witTypes.Some[string](value2084)
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option2085})
+
+						case 34:
+							var option2086 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2086 = witTypes.None[int32]()
+							case 1:
+
+								option2086 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyFutureType(option2086)
+
+						case 35:
+							var option2087 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2087 = witTypes.None[int32]()
+							case 1:
+
+								option2087 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2088 = golem_core_types.MakeSchemaTypeBodyStreamType(option2087)
+
+						default:
+							panic("unreachable")
+						}
+						var option2090 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option2090 = witTypes.None[string]()
+						case 1:
+							value2089 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option2090 = witTypes.Some[string](value2089)
+						default:
+							panic("unreachable")
+						}
+						result2092 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value2091 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2092 = append(result2092, value2091)
+						}
+
+						result2094 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value2093 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2094 = append(result2094, value2093)
+						}
+
+						var option2096 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option2096 = witTypes.None[string]()
+						case 1:
+							value2095 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option2096 = witTypes.Some[string](value2095)
+						default:
+							panic("unreachable")
+						}
+						var option2099 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option2099 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant2098 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant2098 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant2098 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant2098 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value2097 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant2098 = golem_core_types.MakeRoleOther(value2097)
+
+							default:
+								panic("unreachable")
+							}
+
+							option2099 = witTypes.Some[golem_core_types.Role](variant2098)
+						default:
+							panic("unreachable")
+						}
+
+						result2100 = append(result2100, golem_core_types.SchemaTypeNode{variant2088, golem_core_types.MetadataEnvelope{option2090, result2092, result2094, option2096, option2099}})
+					}
+
+					result2104 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))), index*(6*4))
+						value2101 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option2103 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option2103 = witTypes.None[string]()
+						case 1:
+							value2102 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option2103 = witTypes.Some[string](value2102)
+						default:
+							panic("unreachable")
+						}
+
+						result2104 = append(result2104, golem_core_types.SchemaTypeDef{value2101, option2103, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result2128 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))), index*(16+4*4))
+						var variant2127 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value2105 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeStringValue(value2105)
+
+						case 13:
+							result2106 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2106 = append(result2106, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeRecordValue(result2106)
+
+						case 14:
+							var option2107 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option2107 = witTypes.None[int32]()
+							case 1:
+
+								option2107 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option2107})
+
+						case 15:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result2108 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result2108 = append(result2108, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeFlagsValue(result2108)
+
+						case 17:
+							result2109 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2109 = append(result2109, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeTupleValue(result2109)
+
+						case 18:
+							result2110 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2110 = append(result2110, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeListValue(result2110)
+
+						case 19:
+							result2111 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2111 = append(result2111, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeFixedListValue(result2111)
+
+						case 20:
+							result2112 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result2112 = append(result2112, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeMapValue(result2112)
+
+						case 21:
+							var option2113 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2113 = witTypes.None[int32]()
+							case 1:
+
+								option2113 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeOptionValue(option2113)
+
+						case 22:
+							var variant2116 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option2114 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option2114 = witTypes.None[int32]()
+								case 1:
+
+									option2114 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant2116 = golem_core_types.MakeResultValuePayloadOkValue(option2114)
+
+							case 1:
+								var option2115 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option2115 = witTypes.None[int32]()
+								case 1:
+
+									option2115 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant2116 = golem_core_types.MakeResultValuePayloadErrValue(option2115)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeResultValue(variant2116)
+
+						case 23:
+							value2117 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option2119 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option2119 = witTypes.None[string]()
+							case 1:
+								value2118 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option2119 = witTypes.Some[string](value2118)
+							default:
+								panic("unreachable")
+							}
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value2117, option2119})
+
+						case 24:
+							value2120 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option2122 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option2122 = witTypes.None[string]()
+							case 1:
+								value2121 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option2122 = witTypes.Some[string](value2121)
+							default:
+								panic("unreachable")
+							}
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value2120, option2122})
+
+						case 25:
+							value2123 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2127 = golem_core_types.MakeSchemaValueNodePathValue(value2123)
+
+						case 26:
+							value2124 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeUrlValue(value2124)
+
+						case 27:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value2125 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2125})
+
+						case 30:
+							value2126 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value2126, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant2127 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result2128 = append(result2128, variant2127)
+					}
+
+					value2129 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4))))
+					result2131 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))))), index*(2*4))
+						value2130 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result2131 = append(result2131, value2130)
+					}
+
+					result2143 := make([][]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 14*4))))), index*(2*4))
+						result2142 := make([]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*(56+6*4))
+							var variant2141 SpanData
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value2132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var option2134 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) {
+								case 0:
+
+									option2134 = witTypes.None[string]()
+								case 1:
+									value2133 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+									option2134 = witTypes.Some[string](value2133)
+								default:
+									panic("unreachable")
+								}
+								var option2135 witTypes.Option[uint64]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) {
+								case 0:
+
+									option2135 = witTypes.None[uint64]()
+								case 1:
+
+									option2135 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))))
+								default:
+									panic("unreachable")
+								}
+								result2139 := make([]golem_api_context.Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))), index*(5*4))
+									value2136 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+									var variant2138 golem_api_context.AttributeValue
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+									case 0:
+										value2137 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+										variant2138 = golem_api_context.MakeAttributeValueString(value2137)
+
+									default:
+										panic("unreachable")
+									}
+
+									result2139 = append(result2139, golem_api_context.Attribute{value2136, variant2138})
+								}
+
+								variant2141 = MakeSpanDataLocalSpan(LocalSpanData{value2132, wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))}, option2134, option2135, result2139, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)})
+
+							case 1:
+								value2140 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant2141 = MakeSpanDataExternalSpan(ExternalSpanData{value2140})
+
+							default:
+								panic("unreachable")
+							}
+
+							result2142 = append(result2142, variant2141)
+						}
+
+						result2143 = append(result2143, result2142)
+					}
+
+					variant2368 = MakeAgentInvocationAgentInitialization(AgentInitializationParameters{value1924, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result2100, result2104, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))}, golem_core_types.SchemaValueTree{result2128, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4)))}}, value2129, result2131, result2143})
+
+				case 1:
+					value2144 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+					value2145 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+					result2321 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))), index*(56+22*4))
+						var variant2309 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option2152 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2152 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option2147 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option2147 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2146 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant2146 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant2146 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant2146 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2147 = witTypes.Some[golem_core_types.NumericBound](variant2146)
+								default:
+									panic("unreachable")
+								}
+								var option2149 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option2149 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2148 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant2148 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant2148 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant2148 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2149 = witTypes.Some[golem_core_types.NumericBound](variant2148)
+								default:
+									panic("unreachable")
+								}
+								var option2151 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option2151 = witTypes.None[string]()
+								case 1:
+									value2150 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option2151 = witTypes.Some[string](value2150)
+								default:
+									panic("unreachable")
+								}
+
+								option2152 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2147, option2149, option2151})
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyS8Type(option2152)
+
+						case 3:
+							var option2159 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2159 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option2154 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option2154 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2153 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant2153 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant2153 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant2153 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2154 = witTypes.Some[golem_core_types.NumericBound](variant2153)
+								default:
+									panic("unreachable")
+								}
+								var option2156 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option2156 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2155 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant2155 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant2155 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant2155 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2156 = witTypes.Some[golem_core_types.NumericBound](variant2155)
+								default:
+									panic("unreachable")
+								}
+								var option2158 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option2158 = witTypes.None[string]()
+								case 1:
+									value2157 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option2158 = witTypes.Some[string](value2157)
+								default:
+									panic("unreachable")
+								}
+
+								option2159 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2154, option2156, option2158})
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyS16Type(option2159)
+
+						case 4:
+							var option2166 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2166 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option2161 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option2161 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2160 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant2160 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant2160 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant2160 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2161 = witTypes.Some[golem_core_types.NumericBound](variant2160)
+								default:
+									panic("unreachable")
+								}
+								var option2163 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option2163 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2162 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant2162 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant2162 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant2162 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2163 = witTypes.Some[golem_core_types.NumericBound](variant2162)
+								default:
+									panic("unreachable")
+								}
+								var option2165 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option2165 = witTypes.None[string]()
+								case 1:
+									value2164 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option2165 = witTypes.Some[string](value2164)
+								default:
+									panic("unreachable")
+								}
+
+								option2166 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2161, option2163, option2165})
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyS32Type(option2166)
+
+						case 5:
+							var option2173 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2173 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option2168 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option2168 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2167 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant2167 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant2167 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant2167 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2168 = witTypes.Some[golem_core_types.NumericBound](variant2167)
+								default:
+									panic("unreachable")
+								}
+								var option2170 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option2170 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2169 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant2169 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant2169 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant2169 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2170 = witTypes.Some[golem_core_types.NumericBound](variant2169)
+								default:
+									panic("unreachable")
+								}
+								var option2172 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option2172 = witTypes.None[string]()
+								case 1:
+									value2171 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option2172 = witTypes.Some[string](value2171)
+								default:
+									panic("unreachable")
+								}
+
+								option2173 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2168, option2170, option2172})
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyS64Type(option2173)
+
+						case 6:
+							var option2180 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2180 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option2175 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option2175 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2174 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant2174 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant2174 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant2174 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2175 = witTypes.Some[golem_core_types.NumericBound](variant2174)
+								default:
+									panic("unreachable")
+								}
+								var option2177 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option2177 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2176 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant2176 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant2176 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant2176 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2177 = witTypes.Some[golem_core_types.NumericBound](variant2176)
+								default:
+									panic("unreachable")
+								}
+								var option2179 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option2179 = witTypes.None[string]()
+								case 1:
+									value2178 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option2179 = witTypes.Some[string](value2178)
+								default:
+									panic("unreachable")
+								}
+
+								option2180 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2175, option2177, option2179})
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyU8Type(option2180)
+
+						case 7:
+							var option2187 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2187 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option2182 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option2182 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2181 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant2181 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant2181 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant2181 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2182 = witTypes.Some[golem_core_types.NumericBound](variant2181)
+								default:
+									panic("unreachable")
+								}
+								var option2184 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option2184 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2183 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant2183 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant2183 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant2183 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2184 = witTypes.Some[golem_core_types.NumericBound](variant2183)
+								default:
+									panic("unreachable")
+								}
+								var option2186 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option2186 = witTypes.None[string]()
+								case 1:
+									value2185 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option2186 = witTypes.Some[string](value2185)
+								default:
+									panic("unreachable")
+								}
+
+								option2187 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2182, option2184, option2186})
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyU16Type(option2187)
+
+						case 8:
+							var option2194 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2194 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option2189 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option2189 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2188 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant2188 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant2188 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant2188 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2189 = witTypes.Some[golem_core_types.NumericBound](variant2188)
+								default:
+									panic("unreachable")
+								}
+								var option2191 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option2191 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2190 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant2190 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant2190 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant2190 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2191 = witTypes.Some[golem_core_types.NumericBound](variant2190)
+								default:
+									panic("unreachable")
+								}
+								var option2193 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option2193 = witTypes.None[string]()
+								case 1:
+									value2192 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option2193 = witTypes.Some[string](value2192)
+								default:
+									panic("unreachable")
+								}
+
+								option2194 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2189, option2191, option2193})
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyU32Type(option2194)
+
+						case 9:
+							var option2201 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2201 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option2196 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option2196 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2195 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant2195 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant2195 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant2195 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2196 = witTypes.Some[golem_core_types.NumericBound](variant2195)
+								default:
+									panic("unreachable")
+								}
+								var option2198 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option2198 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2197 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant2197 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant2197 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant2197 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2198 = witTypes.Some[golem_core_types.NumericBound](variant2197)
+								default:
+									panic("unreachable")
+								}
+								var option2200 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option2200 = witTypes.None[string]()
+								case 1:
+									value2199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option2200 = witTypes.Some[string](value2199)
+								default:
+									panic("unreachable")
+								}
+
+								option2201 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2196, option2198, option2200})
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyU64Type(option2201)
+
+						case 10:
+							var option2208 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2208 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option2203 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option2203 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2202 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant2202 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant2202 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant2202 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2203 = witTypes.Some[golem_core_types.NumericBound](variant2202)
+								default:
+									panic("unreachable")
+								}
+								var option2205 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option2205 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2204 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant2204 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant2204 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant2204 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2205 = witTypes.Some[golem_core_types.NumericBound](variant2204)
+								default:
+									panic("unreachable")
+								}
+								var option2207 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option2207 = witTypes.None[string]()
+								case 1:
+									value2206 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option2207 = witTypes.Some[string](value2206)
+								default:
+									panic("unreachable")
+								}
+
+								option2208 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2203, option2205, option2207})
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyF32Type(option2208)
+
+						case 11:
+							var option2215 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2215 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option2210 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option2210 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2209 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant2209 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant2209 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant2209 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2210 = witTypes.Some[golem_core_types.NumericBound](variant2209)
+								default:
+									panic("unreachable")
+								}
+								var option2212 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option2212 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant2211 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant2211 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant2211 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant2211 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option2212 = witTypes.Some[golem_core_types.NumericBound](variant2211)
+								default:
+									panic("unreachable")
+								}
+								var option2214 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option2214 = witTypes.None[string]()
+								case 1:
+									value2213 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option2214 = witTypes.Some[string](value2213)
+								default:
+									panic("unreachable")
+								}
+
+								option2215 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2210, option2212, option2214})
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyF64Type(option2215)
+
+						case 12:
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result2228 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value2216 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option2218 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option2218 = witTypes.None[string]()
+								case 1:
+									value2217 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option2218 = witTypes.Some[string](value2217)
+								default:
+									panic("unreachable")
+								}
+								result2220 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value2219 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2220 = append(result2220, value2219)
+								}
+
+								result2222 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value2221 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2222 = append(result2222, value2221)
+								}
+
+								var option2224 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option2224 = witTypes.None[string]()
+								case 1:
+									value2223 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option2224 = witTypes.Some[string](value2223)
+								default:
+									panic("unreachable")
+								}
+								var option2227 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option2227 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant2226 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant2226 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant2226 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant2226 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value2225 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant2226 = golem_core_types.MakeRoleOther(value2225)
+
+									default:
+										panic("unreachable")
+									}
+
+									option2227 = witTypes.Some[golem_core_types.Role](variant2226)
+								default:
+									panic("unreachable")
+								}
+
+								result2228 = append(result2228, golem_core_types.NamedFieldType{value2216, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option2218, result2220, result2222, option2224, option2227}})
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyRecordType(result2228)
+
+						case 15:
+							result2242 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value2229 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option2230 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option2230 = witTypes.None[int32]()
+								case 1:
+
+									option2230 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option2232 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option2232 = witTypes.None[string]()
+								case 1:
+									value2231 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option2232 = witTypes.Some[string](value2231)
+								default:
+									panic("unreachable")
+								}
+								result2234 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value2233 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2234 = append(result2234, value2233)
+								}
+
+								result2236 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value2235 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2236 = append(result2236, value2235)
+								}
+
+								var option2238 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option2238 = witTypes.None[string]()
+								case 1:
+									value2237 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option2238 = witTypes.Some[string](value2237)
+								default:
+									panic("unreachable")
+								}
+								var option2241 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option2241 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant2240 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant2240 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant2240 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant2240 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value2239 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant2240 = golem_core_types.MakeRoleOther(value2239)
+
+									default:
+										panic("unreachable")
+									}
+
+									option2241 = witTypes.Some[golem_core_types.Role](variant2240)
+								default:
+									panic("unreachable")
+								}
+
+								result2242 = append(result2242, golem_core_types.VariantCaseType{value2229, option2230, golem_core_types.MetadataEnvelope{option2232, result2234, result2236, option2238, option2241}})
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyVariantType(result2242)
+
+						case 16:
+							result2244 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value2243 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2244 = append(result2244, value2243)
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyEnumType(result2244)
+
+						case 17:
+							result2246 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value2245 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2246 = append(result2246, value2245)
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyFlagsType(result2246)
+
+						case 18:
+							result2247 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2247 = append(result2247, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyTupleType(result2247)
+
+						case 19:
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option2248 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2248 = witTypes.None[int32]()
+							case 1:
+
+								option2248 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option2249 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2249 = witTypes.None[int32]()
+							case 1:
+
+								option2249 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option2248, option2249})
+
+						case 24:
+							var option2252 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2252 = witTypes.None[[]string]()
+							case 1:
+								result2251 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value2250 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2251 = append(result2251, value2250)
+								}
+
+								option2252 = witTypes.Some[[]string](result2251)
+							default:
+								panic("unreachable")
+							}
+							var option2253 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option2253 = witTypes.None[uint32]()
+							case 1:
+
+								option2253 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option2254 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option2254 = witTypes.None[uint32]()
+							case 1:
+
+								option2254 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option2256 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option2256 = witTypes.None[string]()
+							case 1:
+								value2255 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option2256 = witTypes.Some[string](value2255)
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option2252, option2253, option2254, option2256})
+
+						case 25:
+							var option2259 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2259 = witTypes.None[[]string]()
+							case 1:
+								result2258 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value2257 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2258 = append(result2258, value2257)
+								}
+
+								option2259 = witTypes.Some[[]string](result2258)
+							default:
+								panic("unreachable")
+							}
+							var option2260 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option2260 = witTypes.None[uint32]()
+							case 1:
+
+								option2260 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option2261 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option2261 = witTypes.None[uint32]()
+							case 1:
+
+								option2261 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option2259, option2260, option2261})
+
+						case 26:
+							var option2264 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option2264 = witTypes.None[[]string]()
+							case 1:
+								result2263 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value2262 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2263 = append(result2263, value2262)
+								}
+
+								option2264 = witTypes.Some[[]string](result2263)
+							default:
+								panic("unreachable")
+							}
+							var option2267 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option2267 = witTypes.None[[]string]()
+							case 1:
+								result2266 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value2265 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2266 = append(result2266, value2265)
+								}
+
+								option2267 = witTypes.Some[[]string](result2266)
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option2264, option2267})
+
+						case 27:
+							var option2270 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2270 = witTypes.None[[]string]()
+							case 1:
+								result2269 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value2268 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2269 = append(result2269, value2268)
+								}
+
+								option2270 = witTypes.Some[[]string](result2269)
+							default:
+								panic("unreachable")
+							}
+							var option2273 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option2273 = witTypes.None[[]string]()
+							case 1:
+								result2272 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value2271 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2272 = append(result2272, value2271)
+								}
+
+								option2273 = witTypes.Some[[]string](result2272)
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option2270, option2273})
+
+						case 28:
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value2274 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result2276 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value2275 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2276 = append(result2276, value2275)
+							}
+
+							var option2278 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option2278 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value2277 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option2278 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value2277})
+							default:
+								panic("unreachable")
+							}
+							var option2280 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option2280 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value2279 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option2280 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value2279})
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value2274, result2276, option2278, option2280})
+
+						case 31:
+							result2302 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value2281 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant2290 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value2282 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2290 = golem_core_types.MakeDiscriminatorRulePrefix(value2282)
+
+								case 1:
+									value2283 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2290 = golem_core_types.MakeDiscriminatorRuleSuffix(value2283)
+
+								case 2:
+									value2284 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2290 = golem_core_types.MakeDiscriminatorRuleContains(value2284)
+
+								case 3:
+									value2285 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2290 = golem_core_types.MakeDiscriminatorRuleRegex(value2285)
+
+								case 4:
+									value2286 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option2288 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option2288 = witTypes.None[string]()
+									case 1:
+										value2287 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option2288 = witTypes.Some[string](value2287)
+									default:
+										panic("unreachable")
+									}
+
+									variant2290 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value2286, option2288})
+
+								case 5:
+									value2289 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2290 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value2289)
+
+								default:
+									panic("unreachable")
+								}
+								var option2292 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option2292 = witTypes.None[string]()
+								case 1:
+									value2291 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option2292 = witTypes.Some[string](value2291)
+								default:
+									panic("unreachable")
+								}
+								result2294 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value2293 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2294 = append(result2294, value2293)
+								}
+
+								result2296 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value2295 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2296 = append(result2296, value2295)
+								}
+
+								var option2298 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option2298 = witTypes.None[string]()
+								case 1:
+									value2297 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option2298 = witTypes.Some[string](value2297)
+								default:
+									panic("unreachable")
+								}
+								var option2301 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option2301 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant2300 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant2300 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant2300 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant2300 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value2299 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant2300 = golem_core_types.MakeRoleOther(value2299)
+
+									default:
+										panic("unreachable")
+									}
+
+									option2301 = witTypes.Some[golem_core_types.Role](variant2300)
+								default:
+									panic("unreachable")
+								}
+
+								result2302 = append(result2302, golem_core_types.UnionBranch{value2281, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant2290, golem_core_types.MetadataEnvelope{option2292, result2294, result2296, option2298, option2301}})
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result2302})
+
+						case 32:
+							var option2304 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option2304 = witTypes.None[string]()
+							case 1:
+								value2303 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option2304 = witTypes.Some[string](value2303)
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option2304})
+
+						case 33:
+							var option2306 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2306 = witTypes.None[string]()
+							case 1:
+								value2305 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option2306 = witTypes.Some[string](value2305)
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option2306})
+
+						case 34:
+							var option2307 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2307 = witTypes.None[int32]()
+							case 1:
+
+								option2307 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyFutureType(option2307)
+
+						case 35:
+							var option2308 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2308 = witTypes.None[int32]()
+							case 1:
+
+								option2308 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2309 = golem_core_types.MakeSchemaTypeBodyStreamType(option2308)
+
+						default:
+							panic("unreachable")
+						}
+						var option2311 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option2311 = witTypes.None[string]()
+						case 1:
+							value2310 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option2311 = witTypes.Some[string](value2310)
+						default:
+							panic("unreachable")
+						}
+						result2313 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value2312 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2313 = append(result2313, value2312)
+						}
+
+						result2315 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value2314 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2315 = append(result2315, value2314)
+						}
+
+						var option2317 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option2317 = witTypes.None[string]()
+						case 1:
+							value2316 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option2317 = witTypes.Some[string](value2316)
+						default:
+							panic("unreachable")
+						}
+						var option2320 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option2320 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant2319 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant2319 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant2319 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant2319 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value2318 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant2319 = golem_core_types.MakeRoleOther(value2318)
+
+							default:
+								panic("unreachable")
+							}
+
+							option2320 = witTypes.Some[golem_core_types.Role](variant2319)
+						default:
+							panic("unreachable")
+						}
+
+						result2321 = append(result2321, golem_core_types.SchemaTypeNode{variant2309, golem_core_types.MetadataEnvelope{option2311, result2313, result2315, option2317, option2320}})
+					}
+
+					result2325 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))))), index*(6*4))
+						value2322 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option2324 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option2324 = witTypes.None[string]()
+						case 1:
+							value2323 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option2324 = witTypes.Some[string](value2323)
+						default:
+							panic("unreachable")
+						}
+
+						result2325 = append(result2325, golem_core_types.SchemaTypeDef{value2322, option2324, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result2349 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4))))), index*(16+4*4))
+						var variant2348 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value2326 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeStringValue(value2326)
+
+						case 13:
+							result2327 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2327 = append(result2327, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeRecordValue(result2327)
+
+						case 14:
+							var option2328 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option2328 = witTypes.None[int32]()
+							case 1:
+
+								option2328 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option2328})
+
+						case 15:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result2329 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result2329 = append(result2329, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeFlagsValue(result2329)
+
+						case 17:
+							result2330 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2330 = append(result2330, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeTupleValue(result2330)
+
+						case 18:
+							result2331 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2331 = append(result2331, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeListValue(result2331)
+
+						case 19:
+							result2332 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2332 = append(result2332, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeFixedListValue(result2332)
+
+						case 20:
+							result2333 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result2333 = append(result2333, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeMapValue(result2333)
+
+						case 21:
+							var option2334 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2334 = witTypes.None[int32]()
+							case 1:
+
+								option2334 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeOptionValue(option2334)
+
+						case 22:
+							var variant2337 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option2335 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option2335 = witTypes.None[int32]()
+								case 1:
+
+									option2335 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant2337 = golem_core_types.MakeResultValuePayloadOkValue(option2335)
+
+							case 1:
+								var option2336 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option2336 = witTypes.None[int32]()
+								case 1:
+
+									option2336 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant2337 = golem_core_types.MakeResultValuePayloadErrValue(option2336)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeResultValue(variant2337)
+
+						case 23:
+							value2338 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option2340 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option2340 = witTypes.None[string]()
+							case 1:
+								value2339 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option2340 = witTypes.Some[string](value2339)
+							default:
+								panic("unreachable")
+							}
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value2338, option2340})
+
+						case 24:
+							value2341 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option2343 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option2343 = witTypes.None[string]()
+							case 1:
+								value2342 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option2343 = witTypes.Some[string](value2342)
+							default:
+								panic("unreachable")
+							}
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value2341, option2343})
+
+						case 25:
+							value2344 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2348 = golem_core_types.MakeSchemaValueNodePathValue(value2344)
+
+						case 26:
+							value2345 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeUrlValue(value2345)
+
+						case 27:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value2346 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2346})
+
+						case 30:
+							value2347 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value2347, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant2348 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result2349 = append(result2349, variant2348)
+					}
+
+					value2350 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4))))
+					result2352 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 14*4))))), index*(2*4))
+						value2351 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result2352 = append(result2352, value2351)
+					}
+
+					result2364 := make([][]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 17*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 17*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 16*4))))), index*(2*4))
+						result2363 := make([]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*(56+6*4))
+							var variant2362 SpanData
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value2353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var option2355 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) {
+								case 0:
+
+									option2355 = witTypes.None[string]()
+								case 1:
+									value2354 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+									option2355 = witTypes.Some[string](value2354)
+								default:
+									panic("unreachable")
+								}
+								var option2356 witTypes.Option[uint64]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) {
+								case 0:
+
+									option2356 = witTypes.None[uint64]()
+								case 1:
+
+									option2356 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))))
+								default:
+									panic("unreachable")
+								}
+								result2360 := make([]golem_api_context.Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))), index*(5*4))
+									value2357 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+									var variant2359 golem_api_context.AttributeValue
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+									case 0:
+										value2358 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+										variant2359 = golem_api_context.MakeAttributeValueString(value2358)
+
+									default:
+										panic("unreachable")
+									}
+
+									result2360 = append(result2360, golem_api_context.Attribute{value2357, variant2359})
+								}
+
+								variant2362 = MakeSpanDataLocalSpan(LocalSpanData{value2353, wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))}, option2355, option2356, result2360, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)})
+
+							case 1:
+								value2361 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant2362 = MakeSpanDataExternalSpan(ExternalSpanData{value2361})
+
+							default:
+								panic("unreachable")
+							}
+
+							result2363 = append(result2363, variant2362)
+						}
+
+						result2364 = append(result2364, result2363)
+					}
+
+					variant2368 = MakeAgentInvocationAgentMethodInvocation(AgentMethodInvocationParameters{value2144, value2145, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result2321, result2325, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}, golem_core_types.SchemaValueTree{result2349, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4)))}}, value2350, result2352, result2364})
+
+				case 2:
+
+					variant2368 = MakeAgentInvocationSaveSnapshot()
+
+				case 3:
+					value2365 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+					value2366 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+
+					variant2368 = MakeAgentInvocationLoadSnapshot(LoadSnapshotParameters{SnapshotData{value2365, value2366}})
+
+				case 4:
+					value2367 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+
+					variant2368 = MakeAgentInvocationProcessOplogEntries(ProcessOplogEntriesParameters{value2367})
+
+				case 5:
+
+					variant2368 = MakeAgentInvocationManualUpdate(ManualUpdateParameters{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))})
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2693 = MakePublicOplogEntryPendingAgentInvocation(PendingAgentInvocationParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, variant2368})
+
+			case 15:
+				var variant2371 UpdateDescription
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+				case 0:
+
+					variant2371 = MakeUpdateDescriptionAutoUpdate()
+
+				case 1:
+					value2369 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))
+					value2370 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))
+
+					variant2371 = MakeUpdateDescriptionSnapshotBased(golem_api_host.Snapshot{value2369, value2370})
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2693 = MakePublicOplogEntryPendingUpdate(PendingUpdateParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), variant2371})
+
+			case 16:
+				result2377 := make([]PluginInstallationDescription, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)))), index*(24+6*4))
+					value2372 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+					value2373 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))))
+					result2376 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 5*4))))), index*(4*4))
+						value2374 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						value2375 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+						result2376 = append(result2376, witTypes.Tuple2[string, string]{value2374, value2375})
+					}
+
+					result2377 = append(result2377, PluginInstallationDescription{EnvironmentPluginGrantId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2372, value2373, result2376})
+				}
+
+				variant2693 = MakePublicOplogEntrySuccessfulUpdate(SuccessfulUpdateParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), result2377})
+
+			case 17:
+				var option2379 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+				case 0:
+
+					option2379 = witTypes.None[string]()
+				case 1:
+					value2378 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))
+
+					option2379 = witTypes.Some[string](value2378)
+				default:
+					panic("unreachable")
+				}
+
+				variant2693 = MakePublicOplogEntryFailedUpdate(FailedUpdateParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), option2379})
+
+			case 18:
+
+				variant2693 = MakePublicOplogEntryGrowMemory(GrowMemoryParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24)))})
+
+			case 19:
+
+				variant2693 = MakePublicOplogEntryFilesystemStorageUsageUpdate(FilesystemStorageUsageUpdateParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, *(*int64)(unsafe.Add(unsafe.Pointer(base), 24))})
+
+			case 20:
+				value2380 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+				value2381 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+
+				variant2693 = MakePublicOplogEntryCreateResource(CreateResourceParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), value2380, value2381})
+
+			case 21:
+				value2382 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+				value2383 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+
+				variant2693 = MakePublicOplogEntryDropResource(DropResourceParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), value2382, value2383})
+
+			case 22:
+				value2384 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4))))
+				value2385 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+				variant2693 = MakePublicOplogEntryLog(LogParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24)))), value2384, value2385})
+
+			case 23:
+
+				variant2693 = MakePublicOplogEntryRestart(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}})
+
+			case 24:
+				value2386 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))))
+				value2387 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))
+				result2390 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4))))), index*(4*4))
+					value2388 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value2389 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result2390 = append(result2390, witTypes.Tuple2[string, string]{value2388, value2389})
+				}
+
+				variant2693 = MakePublicOplogEntryActivatePlugin(ActivatePluginParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, PluginInstallationDescription{EnvironmentPluginGrantId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 40)), value2386, value2387, result2390}})
+
+			case 25:
+				value2391 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))))
+				value2392 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))
+				result2395 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4))))), index*(4*4))
+					value2393 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value2394 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result2395 = append(result2395, witTypes.Tuple2[string, string]{value2393, value2394})
+				}
+
+				variant2693 = MakePublicOplogEntryDeactivatePlugin(DeactivatePluginParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, PluginInstallationDescription{EnvironmentPluginGrantId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 40)), value2391, value2392, result2395}})
+
+			case 26:
+
+				variant2693 = MakePublicOplogEntryRevert(RevertParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, OplogRegion{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}})
+
+			case 27:
+				value2396 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+
+				variant2693 = MakePublicOplogEntryCancelPendingInvocation(CancelPendingInvocationParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, value2396})
+
+			case 28:
+				value2397 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+				var option2399 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) {
+				case 0:
+
+					option2399 = witTypes.None[string]()
+				case 1:
+					value2398 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+					option2399 = witTypes.Some[string](value2398)
+				default:
+					panic("unreachable")
+				}
+				var option2401 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) {
+				case 0:
+
+					option2401 = witTypes.None[string]()
+				case 1:
+					value2400 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 7*4))))
+
+					option2401 = witTypes.Some[string](value2400)
+				default:
+					panic("unreachable")
+				}
+				result2405 := make([]golem_api_context.Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 9*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 9*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 8*4))))), index*(5*4))
+					value2402 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var variant2404 golem_api_context.AttributeValue
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+						value2403 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+						variant2404 = golem_api_context.MakeAttributeValueString(value2403)
+
+					default:
+						panic("unreachable")
+					}
+
+					result2405 = append(result2405, golem_api_context.Attribute{value2402, variant2404})
+				}
+
+				variant2693 = MakePublicOplogEntryStartSpan(StartSpanParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, value2397, option2399, option2401, result2405})
+
+			case 29:
+				value2406 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+
+				variant2693 = MakePublicOplogEntryFinishSpan(FinishSpanParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, value2406})
+
+			case 30:
+				value2407 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+				value2408 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))))
+				var variant2410 golem_api_context.AttributeValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) {
+				case 0:
+					value2409 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+					variant2410 = golem_api_context.MakeAttributeValueString(value2409)
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2693 = MakePublicOplogEntrySetSpanAttribute(SetSpanAttributeParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, value2407, value2408, variant2410})
+
+			case 31:
+				var variant2411 golem_api_host.PersistenceLevel
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+				case 0:
+
+					variant2411 = golem_api_host.MakePersistenceLevelPersistNothing()
+
+				case 1:
+
+					variant2411 = golem_api_host.MakePersistenceLevelPersistRemoteSideEffects()
+
+				case 2:
+
+					variant2411 = golem_api_host.MakePersistenceLevelSmart()
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2693 = MakePublicOplogEntryChangePersistenceLevel(ChangePersistenceLevelParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, variant2411})
+
+			case 32:
+				value2412 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+
+				variant2693 = MakePublicOplogEntryBeginRemoteTransaction(BeginRemoteTransactionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, value2412})
+
+			case 33:
+
+				variant2693 = MakePublicOplogEntryPreCommitRemoteTransaction(RemoteTransactionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24)))})
+
+			case 34:
+
+				variant2693 = MakePublicOplogEntryPreRollbackRemoteTransaction(RemoteTransactionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24)))})
+
+			case 35:
+
+				variant2693 = MakePublicOplogEntryCommittedRemoteTransaction(RemoteTransactionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24)))})
+
+			case 36:
+
+				variant2693 = MakePublicOplogEntryRolledBackRemoteTransaction(RemoteTransactionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24)))})
+
+			case 37:
+				value2413 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+				value2414 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))))
+
+				variant2693 = MakePublicOplogEntrySnapshot(SnapshotParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, SnapshotData{value2413, value2414}})
+
+			case 38:
+				value2415 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))))
+				value2416 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))
+				result2419 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4))))), index*(4*4))
+					value2417 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value2418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result2419 = append(result2419, witTypes.Tuple2[string, string]{value2417, value2418})
+				}
+
+				value2420 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 6*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 7*4))))
+
+				variant2693 = MakePublicOplogEntryOplogProcessorCheckpoint(OplogProcessorCheckpointParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, PluginInstallationDescription{EnvironmentPluginGrantId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 40)), value2415, value2416, result2419}, golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (56 + 6*4))))}}, value2420}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 8*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (72 + 8*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (80 + 8*4))))})
+
+			case 39:
+				value2421 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+				result2452 := make([]golem_api_retry.PredicateNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))))), index*(16+4*4))
+					var variant2451 golem_api_retry.PredicateNode
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+						value2422 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2424 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2423 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2424 = golem_api_retry.MakePredicateValueText(value2423)
+
+						case 1:
+
+							variant2424 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2424 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2451 = golem_api_retry.MakePredicateNodePropEq(golem_api_retry.PropertyComparison{value2422, variant2424})
+
+					case 1:
+						value2425 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2427 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2426 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2427 = golem_api_retry.MakePredicateValueText(value2426)
+
+						case 1:
+
+							variant2427 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2427 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2451 = golem_api_retry.MakePredicateNodePropNeq(golem_api_retry.PropertyComparison{value2425, variant2427})
+
+					case 2:
+						value2428 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2430 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2429 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2430 = golem_api_retry.MakePredicateValueText(value2429)
+
+						case 1:
+
+							variant2430 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2430 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2451 = golem_api_retry.MakePredicateNodePropGt(golem_api_retry.PropertyComparison{value2428, variant2430})
+
+					case 3:
+						value2431 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2433 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2432 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2433 = golem_api_retry.MakePredicateValueText(value2432)
+
+						case 1:
+
+							variant2433 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2433 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2451 = golem_api_retry.MakePredicateNodePropGte(golem_api_retry.PropertyComparison{value2431, variant2433})
+
+					case 4:
+						value2434 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2436 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2435 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2436 = golem_api_retry.MakePredicateValueText(value2435)
+
+						case 1:
+
+							variant2436 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2436 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2451 = golem_api_retry.MakePredicateNodePropLt(golem_api_retry.PropertyComparison{value2434, variant2436})
+
+					case 5:
+						value2437 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2439 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2438 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2439 = golem_api_retry.MakePredicateValueText(value2438)
+
+						case 1:
+
+							variant2439 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2439 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2451 = golem_api_retry.MakePredicateNodePropLte(golem_api_retry.PropertyComparison{value2437, variant2439})
+
+					case 6:
+						value2440 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant2451 = golem_api_retry.MakePredicateNodePropExists(value2440)
+
+					case 7:
+						value2441 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						result2444 := make([]golem_api_retry.PredicateValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(8+2*4))
+							var variant2443 golem_api_retry.PredicateValue
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value2442 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant2443 = golem_api_retry.MakePredicateValueText(value2442)
+
+							case 1:
+
+								variant2443 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+							case 2:
+
+								variant2443 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+							default:
+								panic("unreachable")
+							}
+
+							result2444 = append(result2444, variant2443)
+						}
+
+						variant2451 = golem_api_retry.MakePredicateNodePropIn(golem_api_retry.PropertySetCheck{value2441, result2444})
+
+					case 8:
+						value2445 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value2446 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant2451 = golem_api_retry.MakePredicateNodePropMatches(golem_api_retry.PropertyPattern{value2445, value2446})
+
+					case 9:
+						value2447 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value2448 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant2451 = golem_api_retry.MakePredicateNodePropStartsWith(golem_api_retry.PropertyPattern{value2447, value2448})
+
+					case 10:
+						value2449 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value2450 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant2451 = golem_api_retry.MakePredicateNodePropContains(golem_api_retry.PropertyPattern{value2449, value2450})
+
+					case 11:
+
+						variant2451 = golem_api_retry.MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 12:
+
+						variant2451 = golem_api_retry.MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 13:
+
+						variant2451 = golem_api_retry.MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 14:
+
+						variant2451 = golem_api_retry.MakePredicateNodePredTrue()
+
+					case 15:
+
+						variant2451 = golem_api_retry.MakePredicateNodePredFalse()
+
+					default:
+						panic("unreachable")
+					}
+
+					result2452 = append(result2452, variant2451)
+				}
+
+				result2485 := make([]golem_api_retry.PolicyNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))), index*32)
+					var variant2484 golem_api_retry.PolicyNode
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant2484 = golem_api_retry.MakePolicyNodePeriodic(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 1:
+
+						variant2484 = golem_api_retry.MakePolicyNodeExponential(golem_api_retry.ExponentialConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*float64)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+					case 2:
+
+						variant2484 = golem_api_retry.MakePolicyNodeFibonacci(golem_api_retry.FibonacciConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+					case 3:
+
+						variant2484 = golem_api_retry.MakePolicyNodeImmediate()
+
+					case 4:
+
+						variant2484 = golem_api_retry.MakePolicyNodeNever()
+
+					case 5:
+
+						variant2484 = golem_api_retry.MakePolicyNodeCountBox(golem_api_retry.CountBoxConfig{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 6:
+
+						variant2484 = golem_api_retry.MakePolicyNodeTimeBox(golem_api_retry.TimeBoxConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+					case 7:
+
+						variant2484 = golem_api_retry.MakePolicyNodeClampDelay(golem_api_retry.ClampConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 24))})
+
+					case 8:
+
+						variant2484 = golem_api_retry.MakePolicyNodeAddDelay(golem_api_retry.AddDelayConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+					case 9:
+
+						variant2484 = golem_api_retry.MakePolicyNodeJitter(golem_api_retry.JitterConfig{*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+					case 10:
+						result2483 := make([]golem_api_retry.PredicateNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(16+4*4))
+							var variant2482 golem_api_retry.PredicateNode
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value2453 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2455 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2454 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2455 = golem_api_retry.MakePredicateValueText(value2454)
+
+								case 1:
+
+									variant2455 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2455 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2482 = golem_api_retry.MakePredicateNodePropEq(golem_api_retry.PropertyComparison{value2453, variant2455})
+
+							case 1:
+								value2456 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2458 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2457 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2458 = golem_api_retry.MakePredicateValueText(value2457)
+
+								case 1:
+
+									variant2458 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2458 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2482 = golem_api_retry.MakePredicateNodePropNeq(golem_api_retry.PropertyComparison{value2456, variant2458})
+
+							case 2:
+								value2459 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2461 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2460 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2461 = golem_api_retry.MakePredicateValueText(value2460)
+
+								case 1:
+
+									variant2461 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2461 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2482 = golem_api_retry.MakePredicateNodePropGt(golem_api_retry.PropertyComparison{value2459, variant2461})
+
+							case 3:
+								value2462 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2464 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2463 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2464 = golem_api_retry.MakePredicateValueText(value2463)
+
+								case 1:
+
+									variant2464 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2464 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2482 = golem_api_retry.MakePredicateNodePropGte(golem_api_retry.PropertyComparison{value2462, variant2464})
+
+							case 4:
+								value2465 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2467 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2466 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2467 = golem_api_retry.MakePredicateValueText(value2466)
+
+								case 1:
+
+									variant2467 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2467 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2482 = golem_api_retry.MakePredicateNodePropLt(golem_api_retry.PropertyComparison{value2465, variant2467})
+
+							case 5:
+								value2468 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2470 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2469 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2470 = golem_api_retry.MakePredicateValueText(value2469)
+
+								case 1:
+
+									variant2470 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2470 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2482 = golem_api_retry.MakePredicateNodePropLte(golem_api_retry.PropertyComparison{value2468, variant2470})
+
+							case 6:
+								value2471 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant2482 = golem_api_retry.MakePredicateNodePropExists(value2471)
+
+							case 7:
+								value2472 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								result2475 := make([]golem_api_retry.PredicateValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(8+2*4))
+									var variant2474 golem_api_retry.PredicateValue
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+									case 0:
+										value2473 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+										variant2474 = golem_api_retry.MakePredicateValueText(value2473)
+
+									case 1:
+
+										variant2474 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+									case 2:
+
+										variant2474 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+									default:
+										panic("unreachable")
+									}
+
+									result2475 = append(result2475, variant2474)
+								}
+
+								variant2482 = golem_api_retry.MakePredicateNodePropIn(golem_api_retry.PropertySetCheck{value2472, result2475})
+
+							case 8:
+								value2476 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								value2477 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								variant2482 = golem_api_retry.MakePredicateNodePropMatches(golem_api_retry.PropertyPattern{value2476, value2477})
+
+							case 9:
+								value2478 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								value2479 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								variant2482 = golem_api_retry.MakePredicateNodePropStartsWith(golem_api_retry.PropertyPattern{value2478, value2479})
+
+							case 10:
+								value2480 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								value2481 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								variant2482 = golem_api_retry.MakePredicateNodePropContains(golem_api_retry.PropertyPattern{value2480, value2481})
+
+							case 11:
+
+								variant2482 = golem_api_retry.MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+							case 12:
+
+								variant2482 = golem_api_retry.MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+							case 13:
+
+								variant2482 = golem_api_retry.MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+							case 14:
+
+								variant2482 = golem_api_retry.MakePredicateNodePredTrue()
+
+							case 15:
+
+								variant2482 = golem_api_retry.MakePredicateNodePredFalse()
+
+							default:
+								panic("unreachable")
+							}
+
+							result2483 = append(result2483, variant2482)
+						}
+
+						variant2484 = golem_api_retry.MakePolicyNodeFilteredOn(golem_api_retry.FilteredConfig{golem_api_retry.RetryPredicate{result2483}, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+					case 11:
+
+						variant2484 = golem_api_retry.MakePolicyNodeAndThen(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 12:
+
+						variant2484 = golem_api_retry.MakePolicyNodePolicyUnion(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 13:
+
+						variant2484 = golem_api_retry.MakePolicyNodePolicyIntersect(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					default:
+						panic("unreachable")
+					}
+
+					result2485 = append(result2485, variant2484)
+				}
+
+				variant2693 = MakePublicOplogEntrySetRetryPolicy(SetRetryPolicyParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, golem_api_retry.NamedRetryPolicy{value2421, uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))), golem_api_retry.RetryPredicate{result2452}, golem_api_retry.RetryPolicy{result2485}}})
+
+			case 40:
+				value2486 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+
+				variant2693 = MakePublicOplogEntryRemoveRetryPolicy(RemoveRetryPolicyParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, value2486})
+
+			case 41:
+				var variant2487 QueuedCardEvent
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+				case 0:
+
+					variant2487 = MakeQueuedCardEventInstall(QueuedCardEventInstall{golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}}})
+
+				case 1:
+
+					variant2487 = MakeQueuedCardEventRevoke(QueuedCardEventRevoke{golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}}})
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2693 = MakePublicOplogEntryCardEventQueued(CardEventQueuedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, variant2487})
+
+			case 42:
+				var option2488 witTypes.Option[uint64]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+				case 0:
+
+					option2488 = witTypes.None[uint64]()
+				case 1:
+
+					option2488 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+				default:
+					panic("unreachable")
+				}
+
+				variant2693 = MakePublicOplogEntryCardInstalled(CardInstalledParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, option2488, golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 48)))}}})
+
+			case 43:
+
+				variant2693 = MakePublicOplogEntryCardInstallFailed(CardInstallFailedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}}, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))))})
+
+			case 44:
+
+				variant2693 = MakePublicOplogEntryCardRevoked(CardRevokedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}}})
+
+			case 45:
+
+				variant2693 = MakePublicOplogEntryCardExpired(CardExpiredParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}}})
+
+			case 46:
+				result2664 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))), index*(56+22*4))
+					var variant2652 golem_core_types.SchemaTypeBody
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 1:
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+					case 2:
+						var option2495 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2495 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2490 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2490 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2489 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2489 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2489 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2489 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2490 = witTypes.Some[golem_core_types.NumericBound](variant2489)
+							default:
+								panic("unreachable")
+							}
+							var option2492 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2492 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2491 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2491 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2491 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2491 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2492 = witTypes.Some[golem_core_types.NumericBound](variant2491)
+							default:
+								panic("unreachable")
+							}
+							var option2494 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2494 = witTypes.None[string]()
+							case 1:
+								value2493 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2494 = witTypes.Some[string](value2493)
+							default:
+								panic("unreachable")
+							}
+
+							option2495 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2490, option2492, option2494})
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyS8Type(option2495)
+
+					case 3:
+						var option2502 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2502 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2497 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2497 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2496 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2496 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2496 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2496 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2497 = witTypes.Some[golem_core_types.NumericBound](variant2496)
+							default:
+								panic("unreachable")
+							}
+							var option2499 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2499 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2498 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2498 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2498 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2498 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2499 = witTypes.Some[golem_core_types.NumericBound](variant2498)
+							default:
+								panic("unreachable")
+							}
+							var option2501 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2501 = witTypes.None[string]()
+							case 1:
+								value2500 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2501 = witTypes.Some[string](value2500)
+							default:
+								panic("unreachable")
+							}
+
+							option2502 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2497, option2499, option2501})
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyS16Type(option2502)
+
+					case 4:
+						var option2509 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2509 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2504 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2504 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2503 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2503 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2503 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2503 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2504 = witTypes.Some[golem_core_types.NumericBound](variant2503)
+							default:
+								panic("unreachable")
+							}
+							var option2506 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2506 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2505 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2505 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2505 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2505 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2506 = witTypes.Some[golem_core_types.NumericBound](variant2505)
+							default:
+								panic("unreachable")
+							}
+							var option2508 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2508 = witTypes.None[string]()
+							case 1:
+								value2507 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2508 = witTypes.Some[string](value2507)
+							default:
+								panic("unreachable")
+							}
+
+							option2509 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2504, option2506, option2508})
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyS32Type(option2509)
+
+					case 5:
+						var option2516 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2516 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2511 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2511 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2510 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2510 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2510 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2510 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2511 = witTypes.Some[golem_core_types.NumericBound](variant2510)
+							default:
+								panic("unreachable")
+							}
+							var option2513 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2513 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2512 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2512 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2512 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2512 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2513 = witTypes.Some[golem_core_types.NumericBound](variant2512)
+							default:
+								panic("unreachable")
+							}
+							var option2515 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2515 = witTypes.None[string]()
+							case 1:
+								value2514 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2515 = witTypes.Some[string](value2514)
+							default:
+								panic("unreachable")
+							}
+
+							option2516 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2511, option2513, option2515})
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyS64Type(option2516)
+
+					case 6:
+						var option2523 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2523 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2518 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2518 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2517 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2517 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2517 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2517 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2518 = witTypes.Some[golem_core_types.NumericBound](variant2517)
+							default:
+								panic("unreachable")
+							}
+							var option2520 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2520 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2519 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2519 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2519 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2519 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2520 = witTypes.Some[golem_core_types.NumericBound](variant2519)
+							default:
+								panic("unreachable")
+							}
+							var option2522 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2522 = witTypes.None[string]()
+							case 1:
+								value2521 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2522 = witTypes.Some[string](value2521)
+							default:
+								panic("unreachable")
+							}
+
+							option2523 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2518, option2520, option2522})
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyU8Type(option2523)
+
+					case 7:
+						var option2530 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2530 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2525 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2525 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2524 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2524 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2524 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2524 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2525 = witTypes.Some[golem_core_types.NumericBound](variant2524)
+							default:
+								panic("unreachable")
+							}
+							var option2527 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2527 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2526 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2526 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2526 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2526 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2527 = witTypes.Some[golem_core_types.NumericBound](variant2526)
+							default:
+								panic("unreachable")
+							}
+							var option2529 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2529 = witTypes.None[string]()
+							case 1:
+								value2528 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2529 = witTypes.Some[string](value2528)
+							default:
+								panic("unreachable")
+							}
+
+							option2530 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2525, option2527, option2529})
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyU16Type(option2530)
+
+					case 8:
+						var option2537 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2537 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2532 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2532 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2531 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2531 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2531 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2531 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2532 = witTypes.Some[golem_core_types.NumericBound](variant2531)
+							default:
+								panic("unreachable")
+							}
+							var option2534 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2534 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2533 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2533 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2533 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2533 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2534 = witTypes.Some[golem_core_types.NumericBound](variant2533)
+							default:
+								panic("unreachable")
+							}
+							var option2536 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2536 = witTypes.None[string]()
+							case 1:
+								value2535 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2536 = witTypes.Some[string](value2535)
+							default:
+								panic("unreachable")
+							}
+
+							option2537 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2532, option2534, option2536})
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyU32Type(option2537)
+
+					case 9:
+						var option2544 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2544 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2539 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2539 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2538 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2538 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2538 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2538 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2539 = witTypes.Some[golem_core_types.NumericBound](variant2538)
+							default:
+								panic("unreachable")
+							}
+							var option2541 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2541 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2540 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2540 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2540 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2540 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2541 = witTypes.Some[golem_core_types.NumericBound](variant2540)
+							default:
+								panic("unreachable")
+							}
+							var option2543 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2543 = witTypes.None[string]()
+							case 1:
+								value2542 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2543 = witTypes.Some[string](value2542)
+							default:
+								panic("unreachable")
+							}
+
+							option2544 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2539, option2541, option2543})
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyU64Type(option2544)
+
+					case 10:
+						var option2551 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2551 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2546 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2546 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2545 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2545 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2545 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2545 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2546 = witTypes.Some[golem_core_types.NumericBound](variant2545)
+							default:
+								panic("unreachable")
+							}
+							var option2548 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2548 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2547 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2547 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2547 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2547 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2548 = witTypes.Some[golem_core_types.NumericBound](variant2547)
+							default:
+								panic("unreachable")
+							}
+							var option2550 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2550 = witTypes.None[string]()
+							case 1:
+								value2549 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2550 = witTypes.Some[string](value2549)
+							default:
+								panic("unreachable")
+							}
+
+							option2551 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2546, option2548, option2550})
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyF32Type(option2551)
+
+					case 11:
+						var option2558 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2558 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2553 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2553 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2552 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2552 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2552 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2552 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2553 = witTypes.Some[golem_core_types.NumericBound](variant2552)
+							default:
+								panic("unreachable")
+							}
+							var option2555 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2555 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2554 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2554 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2554 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2554 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2555 = witTypes.Some[golem_core_types.NumericBound](variant2554)
+							default:
+								panic("unreachable")
+							}
+							var option2557 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2557 = witTypes.None[string]()
+							case 1:
+								value2556 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2557 = witTypes.Some[string](value2556)
+							default:
+								panic("unreachable")
+							}
+
+							option2558 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2553, option2555, option2557})
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyF64Type(option2558)
+
+					case 12:
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+					case 13:
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+					case 14:
+						result2571 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+							value2559 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var option2561 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+							case 0:
+
+								option2561 = witTypes.None[string]()
+							case 1:
+								value2560 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								option2561 = witTypes.Some[string](value2560)
+							default:
+								panic("unreachable")
+							}
+							result2563 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+								value2562 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2563 = append(result2563, value2562)
+							}
+
+							result2565 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+								value2564 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2565 = append(result2565, value2564)
+							}
+
+							var option2567 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+							case 0:
+
+								option2567 = witTypes.None[string]()
+							case 1:
+								value2566 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+								option2567 = witTypes.Some[string](value2566)
+							default:
+								panic("unreachable")
+							}
+							var option2570 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+							case 0:
+
+								option2570 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant2569 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+								case 0:
+
+									variant2569 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant2569 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant2569 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value2568 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+									variant2569 = golem_core_types.MakeRoleOther(value2568)
+
+								default:
+									panic("unreachable")
+								}
+
+								option2570 = witTypes.Some[golem_core_types.Role](variant2569)
+							default:
+								panic("unreachable")
+							}
+
+							result2571 = append(result2571, golem_core_types.NamedFieldType{value2559, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option2561, result2563, result2565, option2567, option2570}})
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyRecordType(result2571)
+
+					case 15:
+						result2585 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+							value2572 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var option2573 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+							case 0:
+
+								option2573 = witTypes.None[int32]()
+							case 1:
+
+								option2573 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+							default:
+								panic("unreachable")
+							}
+							var option2575 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option2575 = witTypes.None[string]()
+							case 1:
+								value2574 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option2575 = witTypes.Some[string](value2574)
+							default:
+								panic("unreachable")
+							}
+							result2577 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+								value2576 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2577 = append(result2577, value2576)
+							}
+
+							result2579 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+								value2578 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2579 = append(result2579, value2578)
+							}
+
+							var option2581 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+							case 0:
+
+								option2581 = witTypes.None[string]()
+							case 1:
+								value2580 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+								option2581 = witTypes.Some[string](value2580)
+							default:
+								panic("unreachable")
+							}
+							var option2584 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+							case 0:
+
+								option2584 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant2583 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+								case 0:
+
+									variant2583 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant2583 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant2583 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value2582 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+									variant2583 = golem_core_types.MakeRoleOther(value2582)
+
+								default:
+									panic("unreachable")
+								}
+
+								option2584 = witTypes.Some[golem_core_types.Role](variant2583)
+							default:
+								panic("unreachable")
+							}
+
+							result2585 = append(result2585, golem_core_types.VariantCaseType{value2572, option2573, golem_core_types.MetadataEnvelope{option2575, result2577, result2579, option2581, option2584}})
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyVariantType(result2585)
+
+					case 16:
+						result2587 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+							value2586 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2587 = append(result2587, value2586)
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyEnumType(result2587)
+
+					case 17:
+						result2589 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+							value2588 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2589 = append(result2589, value2588)
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyFlagsType(result2589)
+
+					case 18:
+						result2590 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result2590 = append(result2590, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyTupleType(result2590)
+
+					case 19:
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 20:
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+					case 21:
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 22:
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 23:
+						var option2591 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2591 = witTypes.None[int32]()
+						case 1:
+
+							option2591 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+						var option2592 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option2592 = witTypes.None[int32]()
+						case 1:
+
+							option2592 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option2591, option2592})
+
+					case 24:
+						var option2595 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2595 = witTypes.None[[]string]()
+						case 1:
+							result2594 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value2593 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2594 = append(result2594, value2593)
+							}
+
+							option2595 = witTypes.Some[[]string](result2594)
+						default:
+							panic("unreachable")
+						}
+						var option2596 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option2596 = witTypes.None[uint32]()
+						case 1:
+
+							option2596 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option2597 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+						case 0:
+
+							option2597 = witTypes.None[uint32]()
+						case 1:
+
+							option2597 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option2599 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+						case 0:
+
+							option2599 = witTypes.None[string]()
+						case 1:
+							value2598 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+							option2599 = witTypes.Some[string](value2598)
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option2595, option2596, option2597, option2599})
+
+					case 25:
+						var option2602 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2602 = witTypes.None[[]string]()
+						case 1:
+							result2601 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value2600 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2601 = append(result2601, value2600)
+							}
+
+							option2602 = witTypes.Some[[]string](result2601)
+						default:
+							panic("unreachable")
+						}
+						var option2603 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option2603 = witTypes.None[uint32]()
+						case 1:
+
+							option2603 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option2604 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+						case 0:
+
+							option2604 = witTypes.None[uint32]()
+						case 1:
+
+							option2604 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option2602, option2603, option2604})
+
+					case 26:
+						var option2607 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+						case 0:
+
+							option2607 = witTypes.None[[]string]()
+						case 1:
+							result2606 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value2605 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2606 = append(result2606, value2605)
+							}
+
+							option2607 = witTypes.Some[[]string](result2606)
+						default:
+							panic("unreachable")
+						}
+						var option2610 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+						case 0:
+
+							option2610 = witTypes.None[[]string]()
+						case 1:
+							result2609 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+								value2608 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2609 = append(result2609, value2608)
+							}
+
+							option2610 = witTypes.Some[[]string](result2609)
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option2607, option2610})
+
+					case 27:
+						var option2613 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2613 = witTypes.None[[]string]()
+						case 1:
+							result2612 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value2611 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2612 = append(result2612, value2611)
+							}
+
+							option2613 = witTypes.Some[[]string](result2612)
+						default:
+							panic("unreachable")
+						}
+						var option2616 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option2616 = witTypes.None[[]string]()
+						case 1:
+							result2615 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+								value2614 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2615 = append(result2615, value2614)
+							}
+
+							option2616 = witTypes.Some[[]string](result2615)
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option2613, option2616})
+
+					case 28:
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+					case 29:
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+					case 30:
+						value2617 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						result2619 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+							value2618 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2619 = append(result2619, value2618)
+						}
+
+						var option2621 witTypes.Option[golem_core_types.QuantityValue]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+						case 0:
+
+							option2621 = witTypes.None[golem_core_types.QuantityValue]()
+						case 1:
+							value2620 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+							option2621 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value2620})
+						default:
+							panic("unreachable")
+						}
+						var option2623 witTypes.Option[golem_core_types.QuantityValue]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+						case 0:
+
+							option2623 = witTypes.None[golem_core_types.QuantityValue]()
+						case 1:
+							value2622 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+							option2623 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value2622})
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value2617, result2619, option2621, option2623})
+
+					case 31:
+						result2645 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+							value2624 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var variant2633 golem_core_types.DiscriminatorRule
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+							case 0:
+								value2625 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant2633 = golem_core_types.MakeDiscriminatorRulePrefix(value2625)
+
+							case 1:
+								value2626 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant2633 = golem_core_types.MakeDiscriminatorRuleSuffix(value2626)
+
+							case 2:
+								value2627 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant2633 = golem_core_types.MakeDiscriminatorRuleContains(value2627)
+
+							case 3:
+								value2628 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant2633 = golem_core_types.MakeDiscriminatorRuleRegex(value2628)
+
+							case 4:
+								value2629 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+								var option2631 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+								case 0:
+
+									option2631 = witTypes.None[string]()
+								case 1:
+									value2630 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+									option2631 = witTypes.Some[string](value2630)
+								default:
+									panic("unreachable")
+								}
+
+								variant2633 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value2629, option2631})
+
+							case 5:
+								value2632 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant2633 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value2632)
+
+							default:
+								panic("unreachable")
+							}
+							var option2635 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+							case 0:
+
+								option2635 = witTypes.None[string]()
+							case 1:
+								value2634 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+								option2635 = witTypes.Some[string](value2634)
+							default:
+								panic("unreachable")
+							}
+							result2637 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+								value2636 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2637 = append(result2637, value2636)
+							}
+
+							result2639 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+								value2638 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2639 = append(result2639, value2638)
+							}
+
+							var option2641 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+							case 0:
+
+								option2641 = witTypes.None[string]()
+							case 1:
+								value2640 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+								option2641 = witTypes.Some[string](value2640)
+							default:
+								panic("unreachable")
+							}
+							var option2644 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+							case 0:
+
+								option2644 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant2643 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+								case 0:
+
+									variant2643 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant2643 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant2643 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value2642 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+									variant2643 = golem_core_types.MakeRoleOther(value2642)
+
+								default:
+									panic("unreachable")
+								}
+
+								option2644 = witTypes.Some[golem_core_types.Role](variant2643)
+							default:
+								panic("unreachable")
+							}
+
+							result2645 = append(result2645, golem_core_types.UnionBranch{value2624, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant2633, golem_core_types.MetadataEnvelope{option2635, result2637, result2639, option2641, option2644}})
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result2645})
+
+					case 32:
+						var option2647 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+						case 0:
+
+							option2647 = witTypes.None[string]()
+						case 1:
+							value2646 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+							option2647 = witTypes.Some[string](value2646)
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option2647})
+
+					case 33:
+						var option2649 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2649 = witTypes.None[string]()
+						case 1:
+							value2648 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+							option2649 = witTypes.Some[string](value2648)
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option2649})
+
+					case 34:
+						var option2650 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2650 = witTypes.None[int32]()
+						case 1:
+
+							option2650 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyFutureType(option2650)
+
+					case 35:
+						var option2651 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2651 = witTypes.None[int32]()
+						case 1:
+
+							option2651 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant2652 = golem_core_types.MakeSchemaTypeBodyStreamType(option2651)
+
+					default:
+						panic("unreachable")
+					}
+					var option2654 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+					case 0:
+
+						option2654 = witTypes.None[string]()
+					case 1:
+						value2653 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+						option2654 = witTypes.Some[string](value2653)
+					default:
+						panic("unreachable")
+					}
+					result2656 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+						value2655 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result2656 = append(result2656, value2655)
+					}
+
+					result2658 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+						value2657 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result2658 = append(result2658, value2657)
+					}
+
+					var option2660 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+					case 0:
+
+						option2660 = witTypes.None[string]()
+					case 1:
+						value2659 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+						option2660 = witTypes.Some[string](value2659)
+					default:
+						panic("unreachable")
+					}
+					var option2663 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+					case 0:
+
+						option2663 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant2662 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+						case 0:
+
+							variant2662 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant2662 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant2662 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value2661 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+							variant2662 = golem_core_types.MakeRoleOther(value2661)
+
+						default:
+							panic("unreachable")
+						}
+
+						option2663 = witTypes.Some[golem_core_types.Role](variant2662)
+					default:
+						panic("unreachable")
+					}
+
+					result2664 = append(result2664, golem_core_types.SchemaTypeNode{variant2652, golem_core_types.MetadataEnvelope{option2654, result2656, result2658, option2660, option2663}})
+				}
+
+				result2668 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))), index*(6*4))
+					value2665 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var option2667 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+
+						option2667 = witTypes.None[string]()
+					case 1:
+						value2666 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+						option2667 = witTypes.Some[string](value2666)
+					default:
+						panic("unreachable")
+					}
+
+					result2668 = append(result2668, golem_core_types.SchemaTypeDef{value2665, option2667, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+				}
+
+				result2692 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))))), index*(16+4*4))
+					var variant2691 golem_core_types.SchemaValueNode
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+					case 1:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 2:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 3:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 4:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 5:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 6:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 7:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 8:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 9:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 10:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 11:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 12:
+						value2669 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeStringValue(value2669)
+
+					case 13:
+						result2670 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result2670 = append(result2670, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeRecordValue(result2670)
+
+					case 14:
+						var option2671 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+						case 0:
+
+							option2671 = witTypes.None[int32]()
+						case 1:
+
+							option2671 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+						default:
+							panic("unreachable")
+						}
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option2671})
+
+					case 15:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 16:
+						result2672 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+							result2672 = append(result2672, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+						}
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeFlagsValue(result2672)
+
+					case 17:
+						result2673 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result2673 = append(result2673, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeTupleValue(result2673)
+
+					case 18:
+						result2674 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result2674 = append(result2674, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeListValue(result2674)
+
+					case 19:
+						result2675 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result2675 = append(result2675, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeFixedListValue(result2675)
+
+					case 20:
+						result2676 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+							result2676 = append(result2676, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+						}
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeMapValue(result2676)
+
+					case 21:
+						var option2677 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2677 = witTypes.None[int32]()
+						case 1:
+
+							option2677 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeOptionValue(option2677)
+
+					case 22:
+						var variant2680 golem_core_types.ResultValuePayload
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+							var option2678 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option2678 = witTypes.None[int32]()
+							case 1:
+
+								option2678 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2680 = golem_core_types.MakeResultValuePayloadOkValue(option2678)
+
+						case 1:
+							var option2679 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option2679 = witTypes.None[int32]()
+							case 1:
+
+								option2679 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2680 = golem_core_types.MakeResultValuePayloadErrValue(option2679)
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeResultValue(variant2680)
+
+					case 23:
+						value2681 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var option2683 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option2683 = witTypes.None[string]()
+						case 1:
+							value2682 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option2683 = witTypes.Some[string](value2682)
+						default:
+							panic("unreachable")
+						}
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value2681, option2683})
+
+					case 24:
+						value2684 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var option2686 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option2686 = witTypes.None[string]()
+						case 1:
+							value2685 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option2686 = witTypes.Some[string](value2685)
+						default:
+							panic("unreachable")
+						}
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value2684, option2686})
+
+					case 25:
+						value2687 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant2691 = golem_core_types.MakeSchemaValueNodePathValue(value2687)
+
+					case 26:
+						value2688 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeUrlValue(value2688)
+
+					case 27:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+					case 28:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+					case 29:
+						value2689 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2689})
+
+					case 30:
+						value2690 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value2690, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+					case 31:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+					case 32:
+
+						variant2691 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+					default:
+						panic("unreachable")
+					}
+
+					result2692 = append(result2692, variant2691)
+				}
+
+				variant2693 = MakePublicOplogEntryHostStreamFrame(HostStreamFrameParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32)))), golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result2664, result2668, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result2692, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}}})
+
+			case 47:
+
+				variant2693 = MakePublicOplogEntryCompletionDiscarded(CompletionDiscardedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24)))})
+
+			default:
+				panic("unreachable")
+			}
+
+			result2694 = append(result2694, variant2693)
+		}
+
+		result2696 = witTypes.Ok[[]PublicOplogEntry, string](result2694)
+	case 1:
+		value2695 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result2696 = witTypes.Err[[]PublicOplogEntry, string](value2695)
+	default:
+		panic("unreachable")
+	}
+	result2697 := result2696
+	return result2697
+
+}
+
+//go:wasmimport golem:api/oplog@1.5.0 [constructor]get-oplog
+func wasm_import_constructor_get_oplog(arg0 int64, arg1 int64, arg2 uintptr, arg3 uint32, arg4 int64) int32
+
+func MakeGetOplog(agentId golem_core_types.AgentId, start uint64) *GetOplog {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData((agentId).AgentId))
+	pinner.Pin(utf8)
+	result := wasm_import_constructor_get_oplog(int64((((agentId).ComponentId).Uuid).HighBits), int64((((agentId).ComponentId).Uuid).LowBits), uintptr(utf8), uint32(len((agentId).AgentId)), int64(start))
+	return GetOplogFromOwnHandle(int32(uintptr(result)))
+
+}
+
+//go:wasmimport golem:api/oplog@1.5.0 [method]get-oplog.get-next
+func wasm_import_method_get_oplog_get_next(arg0 int32, arg1 uintptr)
+
+func (self *GetOplog) GetNext() witTypes.Option[[]PublicOplogEntry] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_method_get_oplog_get_next((self).Handle(), returnArea)
+	var option2473 witTypes.Option[[]PublicOplogEntry]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option2473 = witTypes.None[[]PublicOplogEntry]()
+	case 1:
+		result2472 := make([]PublicOplogEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(168+10*4))
+			var variant2471 PublicOplogEntry
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+				value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+				result := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 3*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 3*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4))))), index*(4*4))
+					value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result = append(result, witTypes.Tuple2[string, string]{value0, value1})
+				}
+
+				var option witTypes.Option[golem_core_types.AgentId]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (88 + 4*4)))) {
+				case 0:
+
+					option = witTypes.None[golem_core_types.AgentId]()
+				case 1:
+					value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (112 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (112 + 5*4))))
+
+					option = witTypes.Some[golem_core_types.AgentId](golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (96 + 4*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (104 + 4*4))))}}, value2})
+				default:
+					panic("unreachable")
+				}
+				result8 := make([]PluginInstallationDescription, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (128 + 7*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (128 + 7*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (128 + 6*4))))), index*(24+6*4))
+					value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+					value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))))
+					result7 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 5*4))))), index*(4*4))
+						value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+						result7 = append(result7, witTypes.Tuple2[string, string]{value5, value6})
+					}
+
+					result8 = append(result8, PluginInstallationDescription{EnvironmentPluginGrantId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value3, value4, result7})
+				}
+
+				result214 := make([]LocalAgentConfigEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (128 + 9*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (128 + 9*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (128 + 8*4))))), index*(10*4))
+					result10 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*(2*4))
+						value9 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result10 = append(result10, value9)
+					}
+
+					result185 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))), index*(56+22*4))
+						var variant173 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option16 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option16 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option11 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option11 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option11 = witTypes.Some[golem_core_types.NumericBound](variant)
+								default:
+									panic("unreachable")
+								}
+								var option13 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option13 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant12 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant12 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant12 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant12 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option13 = witTypes.Some[golem_core_types.NumericBound](variant12)
+								default:
+									panic("unreachable")
+								}
+								var option15 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option15 = witTypes.None[string]()
+								case 1:
+									value14 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option15 = witTypes.Some[string](value14)
+								default:
+									panic("unreachable")
+								}
+
+								option16 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option11, option13, option15})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyS8Type(option16)
+
+						case 3:
+							var option23 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option23 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option18 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option18 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant17 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant17 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant17 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant17 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option18 = witTypes.Some[golem_core_types.NumericBound](variant17)
+								default:
+									panic("unreachable")
+								}
+								var option20 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option20 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant19 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant19 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant19 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant19 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option20 = witTypes.Some[golem_core_types.NumericBound](variant19)
+								default:
+									panic("unreachable")
+								}
+								var option22 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option22 = witTypes.None[string]()
+								case 1:
+									value21 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option22 = witTypes.Some[string](value21)
+								default:
+									panic("unreachable")
+								}
+
+								option23 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option18, option20, option22})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyS16Type(option23)
+
+						case 4:
+							var option30 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option30 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option25 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option25 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant24 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant24 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant24 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant24 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option25 = witTypes.Some[golem_core_types.NumericBound](variant24)
+								default:
+									panic("unreachable")
+								}
+								var option27 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option27 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant26 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant26 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant26 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant26 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option27 = witTypes.Some[golem_core_types.NumericBound](variant26)
+								default:
+									panic("unreachable")
+								}
+								var option29 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option29 = witTypes.None[string]()
+								case 1:
+									value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option29 = witTypes.Some[string](value28)
+								default:
+									panic("unreachable")
+								}
+
+								option30 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option25, option27, option29})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyS32Type(option30)
+
+						case 5:
+							var option37 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option37 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option32 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option32 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant31 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant31 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant31 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant31 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option32 = witTypes.Some[golem_core_types.NumericBound](variant31)
+								default:
+									panic("unreachable")
+								}
+								var option34 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option34 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant33 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant33 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant33 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant33 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option34 = witTypes.Some[golem_core_types.NumericBound](variant33)
+								default:
+									panic("unreachable")
+								}
+								var option36 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option36 = witTypes.None[string]()
+								case 1:
+									value35 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option36 = witTypes.Some[string](value35)
+								default:
+									panic("unreachable")
+								}
+
+								option37 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option32, option34, option36})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyS64Type(option37)
+
+						case 6:
+							var option44 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option44 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option39 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option39 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant38 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant38 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant38 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant38 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option39 = witTypes.Some[golem_core_types.NumericBound](variant38)
+								default:
+									panic("unreachable")
+								}
+								var option41 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option41 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant40 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant40 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant40 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant40 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option41 = witTypes.Some[golem_core_types.NumericBound](variant40)
+								default:
+									panic("unreachable")
+								}
+								var option43 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option43 = witTypes.None[string]()
+								case 1:
+									value42 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option43 = witTypes.Some[string](value42)
+								default:
+									panic("unreachable")
+								}
+
+								option44 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option39, option41, option43})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyU8Type(option44)
+
+						case 7:
+							var option51 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option51 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option46 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option46 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant45 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant45 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant45 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant45 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option46 = witTypes.Some[golem_core_types.NumericBound](variant45)
+								default:
+									panic("unreachable")
+								}
+								var option48 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option48 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant47 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant47 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant47 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant47 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option48 = witTypes.Some[golem_core_types.NumericBound](variant47)
+								default:
+									panic("unreachable")
+								}
+								var option50 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option50 = witTypes.None[string]()
+								case 1:
+									value49 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option50 = witTypes.Some[string](value49)
+								default:
+									panic("unreachable")
+								}
+
+								option51 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option46, option48, option50})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyU16Type(option51)
+
+						case 8:
+							var option58 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option58 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option53 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option53 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant52 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant52 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant52 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant52 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option53 = witTypes.Some[golem_core_types.NumericBound](variant52)
+								default:
+									panic("unreachable")
+								}
+								var option55 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option55 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant54 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant54 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant54 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant54 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option55 = witTypes.Some[golem_core_types.NumericBound](variant54)
+								default:
+									panic("unreachable")
+								}
+								var option57 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option57 = witTypes.None[string]()
+								case 1:
+									value56 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option57 = witTypes.Some[string](value56)
+								default:
+									panic("unreachable")
+								}
+
+								option58 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option53, option55, option57})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyU32Type(option58)
+
+						case 9:
+							var option65 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option65 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option60 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option60 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant59 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant59 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant59 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant59 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option60 = witTypes.Some[golem_core_types.NumericBound](variant59)
+								default:
+									panic("unreachable")
+								}
+								var option62 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option62 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant61 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant61 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant61 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant61 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option62 = witTypes.Some[golem_core_types.NumericBound](variant61)
+								default:
+									panic("unreachable")
+								}
+								var option64 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option64 = witTypes.None[string]()
+								case 1:
+									value63 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option64 = witTypes.Some[string](value63)
+								default:
+									panic("unreachable")
+								}
+
+								option65 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option60, option62, option64})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyU64Type(option65)
+
+						case 10:
+							var option72 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option72 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option67 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option67 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant66 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant66 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant66 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant66 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option67 = witTypes.Some[golem_core_types.NumericBound](variant66)
+								default:
+									panic("unreachable")
+								}
+								var option69 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option69 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant68 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant68 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant68 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant68 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option69 = witTypes.Some[golem_core_types.NumericBound](variant68)
+								default:
+									panic("unreachable")
+								}
+								var option71 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option71 = witTypes.None[string]()
+								case 1:
+									value70 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option71 = witTypes.Some[string](value70)
+								default:
+									panic("unreachable")
+								}
+
+								option72 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option67, option69, option71})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyF32Type(option72)
+
+						case 11:
+							var option79 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option79 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option74 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option74 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant73 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant73 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant73 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant73 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option74 = witTypes.Some[golem_core_types.NumericBound](variant73)
+								default:
+									panic("unreachable")
+								}
+								var option76 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option76 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant75 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant75 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant75 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant75 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option76 = witTypes.Some[golem_core_types.NumericBound](variant75)
+								default:
+									panic("unreachable")
+								}
+								var option78 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option78 = witTypes.None[string]()
+								case 1:
+									value77 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option78 = witTypes.Some[string](value77)
+								default:
+									panic("unreachable")
+								}
+
+								option79 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option74, option76, option78})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyF64Type(option79)
+
+						case 12:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result92 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value80 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option82 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option82 = witTypes.None[string]()
+								case 1:
+									value81 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option82 = witTypes.Some[string](value81)
+								default:
+									panic("unreachable")
+								}
+								result84 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value83 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result84 = append(result84, value83)
+								}
+
+								result86 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value85 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result86 = append(result86, value85)
+								}
+
+								var option88 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option88 = witTypes.None[string]()
+								case 1:
+									value87 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option88 = witTypes.Some[string](value87)
+								default:
+									panic("unreachable")
+								}
+								var option91 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option91 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant90 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant90 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant90 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant90 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value89 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant90 = golem_core_types.MakeRoleOther(value89)
+
+									default:
+										panic("unreachable")
+									}
+
+									option91 = witTypes.Some[golem_core_types.Role](variant90)
+								default:
+									panic("unreachable")
+								}
+
+								result92 = append(result92, golem_core_types.NamedFieldType{value80, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option82, result84, result86, option88, option91}})
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyRecordType(result92)
+
+						case 15:
+							result106 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value93 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option94 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option94 = witTypes.None[int32]()
+								case 1:
+
+									option94 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option96 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option96 = witTypes.None[string]()
+								case 1:
+									value95 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option96 = witTypes.Some[string](value95)
+								default:
+									panic("unreachable")
+								}
+								result98 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value97 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result98 = append(result98, value97)
+								}
+
+								result100 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value99 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result100 = append(result100, value99)
+								}
+
+								var option102 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option102 = witTypes.None[string]()
+								case 1:
+									value101 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option102 = witTypes.Some[string](value101)
+								default:
+									panic("unreachable")
+								}
+								var option105 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option105 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant104 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant104 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant104 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant104 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value103 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant104 = golem_core_types.MakeRoleOther(value103)
+
+									default:
+										panic("unreachable")
+									}
+
+									option105 = witTypes.Some[golem_core_types.Role](variant104)
+								default:
+									panic("unreachable")
+								}
+
+								result106 = append(result106, golem_core_types.VariantCaseType{value93, option94, golem_core_types.MetadataEnvelope{option96, result98, result100, option102, option105}})
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyVariantType(result106)
+
+						case 16:
+							result108 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value107 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result108 = append(result108, value107)
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyEnumType(result108)
+
+						case 17:
+							result110 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value109 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result110 = append(result110, value109)
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyFlagsType(result110)
+
+						case 18:
+							result111 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result111 = append(result111, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyTupleType(result111)
+
+						case 19:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option112 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option112 = witTypes.None[int32]()
+							case 1:
+
+								option112 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option113 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option113 = witTypes.None[int32]()
+							case 1:
+
+								option113 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option112, option113})
+
+						case 24:
+							var option116 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option116 = witTypes.None[[]string]()
+							case 1:
+								result115 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value114 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result115 = append(result115, value114)
+								}
+
+								option116 = witTypes.Some[[]string](result115)
+							default:
+								panic("unreachable")
+							}
+							var option117 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option117 = witTypes.None[uint32]()
+							case 1:
+
+								option117 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option118 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option118 = witTypes.None[uint32]()
+							case 1:
+
+								option118 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option120 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option120 = witTypes.None[string]()
+							case 1:
+								value119 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option120 = witTypes.Some[string](value119)
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option116, option117, option118, option120})
+
+						case 25:
+							var option123 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option123 = witTypes.None[[]string]()
+							case 1:
+								result122 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value121 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result122 = append(result122, value121)
+								}
+
+								option123 = witTypes.Some[[]string](result122)
+							default:
+								panic("unreachable")
+							}
+							var option124 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option124 = witTypes.None[uint32]()
+							case 1:
+
+								option124 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option125 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option125 = witTypes.None[uint32]()
+							case 1:
+
+								option125 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option123, option124, option125})
+
+						case 26:
+							var option128 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option128 = witTypes.None[[]string]()
+							case 1:
+								result127 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value126 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result127 = append(result127, value126)
+								}
+
+								option128 = witTypes.Some[[]string](result127)
+							default:
+								panic("unreachable")
+							}
+							var option131 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option131 = witTypes.None[[]string]()
+							case 1:
+								result130 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value129 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result130 = append(result130, value129)
+								}
+
+								option131 = witTypes.Some[[]string](result130)
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option128, option131})
+
+						case 27:
+							var option134 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option134 = witTypes.None[[]string]()
+							case 1:
+								result133 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result133 = append(result133, value132)
+								}
+
+								option134 = witTypes.Some[[]string](result133)
+							default:
+								panic("unreachable")
+							}
+							var option137 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option137 = witTypes.None[[]string]()
+							case 1:
+								result136 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result136 = append(result136, value135)
+								}
+
+								option137 = witTypes.Some[[]string](result136)
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option134, option137})
+
+						case 28:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value138 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result140 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value139 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result140 = append(result140, value139)
+							}
+
+							var option142 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option142 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value141 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option142 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value141})
+							default:
+								panic("unreachable")
+							}
+							var option144 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option144 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value143 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option144 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value143})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value138, result140, option142, option144})
+
+						case 31:
+							result166 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value145 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant154 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant154 = golem_core_types.MakeDiscriminatorRulePrefix(value146)
+
+								case 1:
+									value147 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant154 = golem_core_types.MakeDiscriminatorRuleSuffix(value147)
+
+								case 2:
+									value148 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant154 = golem_core_types.MakeDiscriminatorRuleContains(value148)
+
+								case 3:
+									value149 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant154 = golem_core_types.MakeDiscriminatorRuleRegex(value149)
+
+								case 4:
+									value150 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option152 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option152 = witTypes.None[string]()
+									case 1:
+										value151 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option152 = witTypes.Some[string](value151)
+									default:
+										panic("unreachable")
+									}
+
+									variant154 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value150, option152})
+
+								case 5:
+									value153 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant154 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value153)
+
+								default:
+									panic("unreachable")
+								}
+								var option156 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option156 = witTypes.None[string]()
+								case 1:
+									value155 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option156 = witTypes.Some[string](value155)
+								default:
+									panic("unreachable")
+								}
+								result158 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value157 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result158 = append(result158, value157)
+								}
+
+								result160 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value159 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result160 = append(result160, value159)
+								}
+
+								var option162 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option162 = witTypes.None[string]()
+								case 1:
+									value161 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option162 = witTypes.Some[string](value161)
+								default:
+									panic("unreachable")
+								}
+								var option165 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option165 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant164 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant164 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant164 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant164 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value163 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant164 = golem_core_types.MakeRoleOther(value163)
+
+									default:
+										panic("unreachable")
+									}
+
+									option165 = witTypes.Some[golem_core_types.Role](variant164)
+								default:
+									panic("unreachable")
+								}
+
+								result166 = append(result166, golem_core_types.UnionBranch{value145, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant154, golem_core_types.MetadataEnvelope{option156, result158, result160, option162, option165}})
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result166})
+
+						case 32:
+							var option168 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option168 = witTypes.None[string]()
+							case 1:
+								value167 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option168 = witTypes.Some[string](value167)
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option168})
+
+						case 33:
+							var option170 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option170 = witTypes.None[string]()
+							case 1:
+								value169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option170 = witTypes.Some[string](value169)
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option170})
+
+						case 34:
+							var option171 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option171 = witTypes.None[int32]()
+							case 1:
+
+								option171 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyFutureType(option171)
+
+						case 35:
+							var option172 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option172 = witTypes.None[int32]()
+							case 1:
+
+								option172 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyStreamType(option172)
+
+						default:
+							panic("unreachable")
+						}
+						var option175 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option175 = witTypes.None[string]()
+						case 1:
+							value174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option175 = witTypes.Some[string](value174)
+						default:
+							panic("unreachable")
+						}
+						result177 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result177 = append(result177, value176)
+						}
+
+						result179 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value178 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result179 = append(result179, value178)
+						}
+
+						var option181 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option181 = witTypes.None[string]()
+						case 1:
+							value180 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option181 = witTypes.Some[string](value180)
+						default:
+							panic("unreachable")
+						}
+						var option184 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option184 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant183 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant183 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant183 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant183 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value182 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant183 = golem_core_types.MakeRoleOther(value182)
+
+							default:
+								panic("unreachable")
+							}
+
+							option184 = witTypes.Some[golem_core_types.Role](variant183)
+						default:
+							panic("unreachable")
+						}
+
+						result185 = append(result185, golem_core_types.SchemaTypeNode{variant173, golem_core_types.MetadataEnvelope{option175, result177, result179, option181, option184}})
+					}
+
+					result189 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))), index*(6*4))
+						value186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option188 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option188 = witTypes.None[string]()
+						case 1:
+							value187 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option188 = witTypes.Some[string](value187)
+						default:
+							panic("unreachable")
+						}
+
+						result189 = append(result189, golem_core_types.SchemaTypeDef{value186, option188, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result213 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))), index*(16+4*4))
+						var variant212 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value190 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant212 = golem_core_types.MakeSchemaValueNodeStringValue(value190)
+
+						case 13:
+							result191 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result191 = append(result191, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeRecordValue(result191)
+
+						case 14:
+							var option192 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option192 = witTypes.None[int32]()
+							case 1:
+
+								option192 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option192})
+
+						case 15:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result193 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result193 = append(result193, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeFlagsValue(result193)
+
+						case 17:
+							result194 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result194 = append(result194, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeTupleValue(result194)
+
+						case 18:
+							result195 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result195 = append(result195, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeListValue(result195)
+
+						case 19:
+							result196 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result196 = append(result196, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeFixedListValue(result196)
+
+						case 20:
+							result197 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result197 = append(result197, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeMapValue(result197)
+
+						case 21:
+							var option198 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option198 = witTypes.None[int32]()
+							case 1:
+
+								option198 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeOptionValue(option198)
+
+						case 22:
+							var variant201 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option199 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option199 = witTypes.None[int32]()
+								case 1:
+
+									option199 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant201 = golem_core_types.MakeResultValuePayloadOkValue(option199)
+
+							case 1:
+								var option200 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option200 = witTypes.None[int32]()
+								case 1:
+
+									option200 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant201 = golem_core_types.MakeResultValuePayloadErrValue(option200)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeResultValue(variant201)
+
+						case 23:
+							value202 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option204 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option204 = witTypes.None[string]()
+							case 1:
+								value203 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option204 = witTypes.Some[string](value203)
+							default:
+								panic("unreachable")
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value202, option204})
+
+						case 24:
+							value205 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option207 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option207 = witTypes.None[string]()
+							case 1:
+								value206 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option207 = witTypes.Some[string](value206)
+							default:
+								panic("unreachable")
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value205, option207})
+
+						case 25:
+							value208 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant212 = golem_core_types.MakeSchemaValueNodePathValue(value208)
+
+						case 26:
+							value209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant212 = golem_core_types.MakeSchemaValueNodeUrlValue(value209)
+
+						case 27:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value210 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant212 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value210})
+
+						case 30:
+							value211 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant212 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value211, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result213 = append(result213, variant212)
+					}
+
+					result214 = append(result214, LocalAgentConfigEntry{result10, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result185, result189, *(*int32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))}, golem_core_types.SchemaValueTree{result213, *(*int32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))}}})
+				}
+
+				var option215 witTypes.Option[golem_core_types.Uuid]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (128 + 10*4)))) {
+				case 0:
+
+					option215 = witTypes.None[golem_core_types.Uuid]()
+				case 1:
+
+					option215 = witTypes.Some[golem_core_types.Uuid](golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (136 + 10*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (144 + 10*4))))})
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryCreate(CreateParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}}, value}, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4)))), result, golem_core_types.AccountId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (56 + 4*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 4*4))))}}, golem_api_host.EnvironmentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (72 + 4*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (80 + 4*4))))}}, option, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (112 + 6*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (120 + 6*4)))), result8, result214, option215, golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (152 + 10*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (160 + 10*4))))}})
+
+			case 1:
+				var option216 witTypes.Option[uint64]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+				case 0:
+
+					option216 = witTypes.None[uint64]()
+				case 1:
+
+					option216 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+				default:
+					panic("unreachable")
+				}
+				value217 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+				var option422 witTypes.Option[golem_core_types.TypedSchemaValue]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))) {
+				case 0:
+
+					option422 = witTypes.None[golem_core_types.TypedSchemaValue]()
+				case 1:
+					result393 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))))), index*(56+22*4))
+						var variant381 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option224 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option224 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option219 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option219 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant218 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant218 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant218 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant218 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option219 = witTypes.Some[golem_core_types.NumericBound](variant218)
+								default:
+									panic("unreachable")
+								}
+								var option221 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option221 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant220 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant220 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant220 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant220 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option221 = witTypes.Some[golem_core_types.NumericBound](variant220)
+								default:
+									panic("unreachable")
+								}
+								var option223 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option223 = witTypes.None[string]()
+								case 1:
+									value222 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option223 = witTypes.Some[string](value222)
+								default:
+									panic("unreachable")
+								}
+
+								option224 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option219, option221, option223})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyS8Type(option224)
+
+						case 3:
+							var option231 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option231 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option226 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option226 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant225 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant225 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant225 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant225 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option226 = witTypes.Some[golem_core_types.NumericBound](variant225)
+								default:
+									panic("unreachable")
+								}
+								var option228 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option228 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant227 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant227 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant227 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant227 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option228 = witTypes.Some[golem_core_types.NumericBound](variant227)
+								default:
+									panic("unreachable")
+								}
+								var option230 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option230 = witTypes.None[string]()
+								case 1:
+									value229 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option230 = witTypes.Some[string](value229)
+								default:
+									panic("unreachable")
+								}
+
+								option231 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option226, option228, option230})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyS16Type(option231)
+
+						case 4:
+							var option238 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option238 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option233 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option233 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant232 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant232 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant232 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant232 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option233 = witTypes.Some[golem_core_types.NumericBound](variant232)
+								default:
+									panic("unreachable")
+								}
+								var option235 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option235 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant234 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant234 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant234 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant234 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option235 = witTypes.Some[golem_core_types.NumericBound](variant234)
+								default:
+									panic("unreachable")
+								}
+								var option237 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option237 = witTypes.None[string]()
+								case 1:
+									value236 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option237 = witTypes.Some[string](value236)
+								default:
+									panic("unreachable")
+								}
+
+								option238 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option233, option235, option237})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyS32Type(option238)
+
+						case 5:
+							var option245 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option245 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option240 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option240 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant239 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant239 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant239 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant239 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option240 = witTypes.Some[golem_core_types.NumericBound](variant239)
+								default:
+									panic("unreachable")
+								}
+								var option242 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option242 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant241 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant241 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant241 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant241 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option242 = witTypes.Some[golem_core_types.NumericBound](variant241)
+								default:
+									panic("unreachable")
+								}
+								var option244 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option244 = witTypes.None[string]()
+								case 1:
+									value243 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option244 = witTypes.Some[string](value243)
+								default:
+									panic("unreachable")
+								}
+
+								option245 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option240, option242, option244})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyS64Type(option245)
+
+						case 6:
+							var option252 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option252 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option247 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option247 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant246 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant246 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant246 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant246 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option247 = witTypes.Some[golem_core_types.NumericBound](variant246)
+								default:
+									panic("unreachable")
+								}
+								var option249 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option249 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant248 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant248 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant248 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant248 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option249 = witTypes.Some[golem_core_types.NumericBound](variant248)
+								default:
+									panic("unreachable")
+								}
+								var option251 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option251 = witTypes.None[string]()
+								case 1:
+									value250 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option251 = witTypes.Some[string](value250)
+								default:
+									panic("unreachable")
+								}
+
+								option252 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option247, option249, option251})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyU8Type(option252)
+
+						case 7:
+							var option259 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option259 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option254 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option254 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant253 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant253 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant253 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant253 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option254 = witTypes.Some[golem_core_types.NumericBound](variant253)
+								default:
+									panic("unreachable")
+								}
+								var option256 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option256 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant255 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant255 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant255 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant255 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option256 = witTypes.Some[golem_core_types.NumericBound](variant255)
+								default:
+									panic("unreachable")
+								}
+								var option258 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option258 = witTypes.None[string]()
+								case 1:
+									value257 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option258 = witTypes.Some[string](value257)
+								default:
+									panic("unreachable")
+								}
+
+								option259 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option254, option256, option258})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyU16Type(option259)
+
+						case 8:
+							var option266 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option266 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option261 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option261 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant260 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant260 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant260 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant260 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option261 = witTypes.Some[golem_core_types.NumericBound](variant260)
+								default:
+									panic("unreachable")
+								}
+								var option263 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option263 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant262 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant262 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant262 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant262 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option263 = witTypes.Some[golem_core_types.NumericBound](variant262)
+								default:
+									panic("unreachable")
+								}
+								var option265 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option265 = witTypes.None[string]()
+								case 1:
+									value264 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option265 = witTypes.Some[string](value264)
+								default:
+									panic("unreachable")
+								}
+
+								option266 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option261, option263, option265})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyU32Type(option266)
+
+						case 9:
+							var option273 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option273 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option268 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option268 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant267 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant267 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant267 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant267 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option268 = witTypes.Some[golem_core_types.NumericBound](variant267)
+								default:
+									panic("unreachable")
+								}
+								var option270 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option270 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant269 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant269 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant269 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant269 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option270 = witTypes.Some[golem_core_types.NumericBound](variant269)
+								default:
+									panic("unreachable")
+								}
+								var option272 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option272 = witTypes.None[string]()
+								case 1:
+									value271 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option272 = witTypes.Some[string](value271)
+								default:
+									panic("unreachable")
+								}
+
+								option273 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option268, option270, option272})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyU64Type(option273)
+
+						case 10:
+							var option280 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option280 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option275 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option275 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant274 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant274 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant274 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant274 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option275 = witTypes.Some[golem_core_types.NumericBound](variant274)
+								default:
+									panic("unreachable")
+								}
+								var option277 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option277 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant276 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant276 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant276 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant276 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option277 = witTypes.Some[golem_core_types.NumericBound](variant276)
+								default:
+									panic("unreachable")
+								}
+								var option279 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option279 = witTypes.None[string]()
+								case 1:
+									value278 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option279 = witTypes.Some[string](value278)
+								default:
+									panic("unreachable")
+								}
+
+								option280 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option275, option277, option279})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyF32Type(option280)
+
+						case 11:
+							var option287 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option287 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option282 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option282 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant281 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant281 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant281 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant281 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option282 = witTypes.Some[golem_core_types.NumericBound](variant281)
+								default:
+									panic("unreachable")
+								}
+								var option284 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option284 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant283 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant283 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant283 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant283 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option284 = witTypes.Some[golem_core_types.NumericBound](variant283)
+								default:
+									panic("unreachable")
+								}
+								var option286 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option286 = witTypes.None[string]()
+								case 1:
+									value285 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option286 = witTypes.Some[string](value285)
+								default:
+									panic("unreachable")
+								}
+
+								option287 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option282, option284, option286})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyF64Type(option287)
+
+						case 12:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result300 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value288 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option290 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option290 = witTypes.None[string]()
+								case 1:
+									value289 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option290 = witTypes.Some[string](value289)
+								default:
+									panic("unreachable")
+								}
+								result292 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value291 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result292 = append(result292, value291)
+								}
+
+								result294 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value293 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result294 = append(result294, value293)
+								}
+
+								var option296 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option296 = witTypes.None[string]()
+								case 1:
+									value295 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option296 = witTypes.Some[string](value295)
+								default:
+									panic("unreachable")
+								}
+								var option299 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option299 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant298 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant298 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant298 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant298 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value297 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant298 = golem_core_types.MakeRoleOther(value297)
+
+									default:
+										panic("unreachable")
+									}
+
+									option299 = witTypes.Some[golem_core_types.Role](variant298)
+								default:
+									panic("unreachable")
+								}
+
+								result300 = append(result300, golem_core_types.NamedFieldType{value288, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option290, result292, result294, option296, option299}})
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyRecordType(result300)
+
+						case 15:
+							result314 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value301 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option302 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option302 = witTypes.None[int32]()
+								case 1:
+
+									option302 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option304 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option304 = witTypes.None[string]()
+								case 1:
+									value303 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option304 = witTypes.Some[string](value303)
+								default:
+									panic("unreachable")
+								}
+								result306 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value305 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result306 = append(result306, value305)
+								}
+
+								result308 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value307 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result308 = append(result308, value307)
+								}
+
+								var option310 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option310 = witTypes.None[string]()
+								case 1:
+									value309 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option310 = witTypes.Some[string](value309)
+								default:
+									panic("unreachable")
+								}
+								var option313 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option313 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant312 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant312 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant312 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant312 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value311 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant312 = golem_core_types.MakeRoleOther(value311)
+
+									default:
+										panic("unreachable")
+									}
+
+									option313 = witTypes.Some[golem_core_types.Role](variant312)
+								default:
+									panic("unreachable")
+								}
+
+								result314 = append(result314, golem_core_types.VariantCaseType{value301, option302, golem_core_types.MetadataEnvelope{option304, result306, result308, option310, option313}})
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyVariantType(result314)
+
+						case 16:
+							result316 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value315 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result316 = append(result316, value315)
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyEnumType(result316)
+
+						case 17:
+							result318 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value317 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result318 = append(result318, value317)
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyFlagsType(result318)
+
+						case 18:
+							result319 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result319 = append(result319, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyTupleType(result319)
+
+						case 19:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option320 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option320 = witTypes.None[int32]()
+							case 1:
+
+								option320 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option321 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option321 = witTypes.None[int32]()
+							case 1:
+
+								option321 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option320, option321})
+
+						case 24:
+							var option324 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option324 = witTypes.None[[]string]()
+							case 1:
+								result323 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value322 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result323 = append(result323, value322)
+								}
+
+								option324 = witTypes.Some[[]string](result323)
+							default:
+								panic("unreachable")
+							}
+							var option325 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option325 = witTypes.None[uint32]()
+							case 1:
+
+								option325 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option326 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option326 = witTypes.None[uint32]()
+							case 1:
+
+								option326 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option328 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option328 = witTypes.None[string]()
+							case 1:
+								value327 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option328 = witTypes.Some[string](value327)
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option324, option325, option326, option328})
+
+						case 25:
+							var option331 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option331 = witTypes.None[[]string]()
+							case 1:
+								result330 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value329 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result330 = append(result330, value329)
+								}
+
+								option331 = witTypes.Some[[]string](result330)
+							default:
+								panic("unreachable")
+							}
+							var option332 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option332 = witTypes.None[uint32]()
+							case 1:
+
+								option332 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option333 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option333 = witTypes.None[uint32]()
+							case 1:
+
+								option333 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option331, option332, option333})
+
+						case 26:
+							var option336 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option336 = witTypes.None[[]string]()
+							case 1:
+								result335 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value334 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result335 = append(result335, value334)
+								}
+
+								option336 = witTypes.Some[[]string](result335)
+							default:
+								panic("unreachable")
+							}
+							var option339 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option339 = witTypes.None[[]string]()
+							case 1:
+								result338 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value337 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result338 = append(result338, value337)
+								}
+
+								option339 = witTypes.Some[[]string](result338)
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option336, option339})
+
+						case 27:
+							var option342 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option342 = witTypes.None[[]string]()
+							case 1:
+								result341 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value340 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result341 = append(result341, value340)
+								}
+
+								option342 = witTypes.Some[[]string](result341)
+							default:
+								panic("unreachable")
+							}
+							var option345 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option345 = witTypes.None[[]string]()
+							case 1:
+								result344 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value343 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result344 = append(result344, value343)
+								}
+
+								option345 = witTypes.Some[[]string](result344)
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option342, option345})
+
+						case 28:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value346 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result348 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value347 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result348 = append(result348, value347)
+							}
+
+							var option350 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option350 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value349 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option350 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value349})
+							default:
+								panic("unreachable")
+							}
+							var option352 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option352 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value351 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option352 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value351})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value346, result348, option350, option352})
+
+						case 31:
+							result374 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant362 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value354 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant362 = golem_core_types.MakeDiscriminatorRulePrefix(value354)
+
+								case 1:
+									value355 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant362 = golem_core_types.MakeDiscriminatorRuleSuffix(value355)
+
+								case 2:
+									value356 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant362 = golem_core_types.MakeDiscriminatorRuleContains(value356)
+
+								case 3:
+									value357 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant362 = golem_core_types.MakeDiscriminatorRuleRegex(value357)
+
+								case 4:
+									value358 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option360 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option360 = witTypes.None[string]()
+									case 1:
+										value359 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option360 = witTypes.Some[string](value359)
+									default:
+										panic("unreachable")
+									}
+
+									variant362 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value358, option360})
+
+								case 5:
+									value361 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant362 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value361)
+
+								default:
+									panic("unreachable")
+								}
+								var option364 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option364 = witTypes.None[string]()
+								case 1:
+									value363 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option364 = witTypes.Some[string](value363)
+								default:
+									panic("unreachable")
+								}
+								result366 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value365 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result366 = append(result366, value365)
+								}
+
+								result368 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value367 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result368 = append(result368, value367)
+								}
+
+								var option370 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option370 = witTypes.None[string]()
+								case 1:
+									value369 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option370 = witTypes.Some[string](value369)
+								default:
+									panic("unreachable")
+								}
+								var option373 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option373 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant372 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant372 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant372 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant372 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value371 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant372 = golem_core_types.MakeRoleOther(value371)
+
+									default:
+										panic("unreachable")
+									}
+
+									option373 = witTypes.Some[golem_core_types.Role](variant372)
+								default:
+									panic("unreachable")
+								}
+
+								result374 = append(result374, golem_core_types.UnionBranch{value353, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant362, golem_core_types.MetadataEnvelope{option364, result366, result368, option370, option373}})
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result374})
+
+						case 32:
+							var option376 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option376 = witTypes.None[string]()
+							case 1:
+								value375 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option376 = witTypes.Some[string](value375)
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option376})
+
+						case 33:
+							var option378 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option378 = witTypes.None[string]()
+							case 1:
+								value377 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option378 = witTypes.Some[string](value377)
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option378})
+
+						case 34:
+							var option379 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option379 = witTypes.None[int32]()
+							case 1:
+
+								option379 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyFutureType(option379)
+
+						case 35:
+							var option380 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option380 = witTypes.None[int32]()
+							case 1:
+
+								option380 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyStreamType(option380)
+
+						default:
+							panic("unreachable")
+						}
+						var option383 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option383 = witTypes.None[string]()
+						case 1:
+							value382 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option383 = witTypes.Some[string](value382)
+						default:
+							panic("unreachable")
+						}
+						result385 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value384 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result385 = append(result385, value384)
+						}
+
+						result387 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value386 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result387 = append(result387, value386)
+						}
+
+						var option389 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option389 = witTypes.None[string]()
+						case 1:
+							value388 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option389 = witTypes.Some[string](value388)
+						default:
+							panic("unreachable")
+						}
+						var option392 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option392 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant391 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant391 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant391 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant391 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value390 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant391 = golem_core_types.MakeRoleOther(value390)
+
+							default:
+								panic("unreachable")
+							}
+
+							option392 = witTypes.Some[golem_core_types.Role](variant391)
+						default:
+							panic("unreachable")
+						}
+
+						result393 = append(result393, golem_core_types.SchemaTypeNode{variant381, golem_core_types.MetadataEnvelope{option383, result385, result387, option389, option392}})
+					}
+
+					result397 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4))))), index*(6*4))
+						value394 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option396 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option396 = witTypes.None[string]()
+						case 1:
+							value395 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option396 = witTypes.Some[string](value395)
+						default:
+							panic("unreachable")
+						}
+
+						result397 = append(result397, golem_core_types.SchemaTypeDef{value394, option396, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result421 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 9*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 9*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4))))), index*(16+4*4))
+						var variant420 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value398 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant420 = golem_core_types.MakeSchemaValueNodeStringValue(value398)
+
+						case 13:
+							result399 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result399 = append(result399, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeRecordValue(result399)
+
+						case 14:
+							var option400 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option400 = witTypes.None[int32]()
+							case 1:
+
+								option400 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option400})
+
+						case 15:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result401 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result401 = append(result401, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeFlagsValue(result401)
+
+						case 17:
+							result402 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result402 = append(result402, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeTupleValue(result402)
+
+						case 18:
+							result403 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result403 = append(result403, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeListValue(result403)
+
+						case 19:
+							result404 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result404 = append(result404, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeFixedListValue(result404)
+
+						case 20:
+							result405 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result405 = append(result405, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeMapValue(result405)
+
+						case 21:
+							var option406 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option406 = witTypes.None[int32]()
+							case 1:
+
+								option406 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeOptionValue(option406)
+
+						case 22:
+							var variant409 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option407 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option407 = witTypes.None[int32]()
+								case 1:
+
+									option407 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant409 = golem_core_types.MakeResultValuePayloadOkValue(option407)
+
+							case 1:
+								var option408 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option408 = witTypes.None[int32]()
+								case 1:
+
+									option408 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant409 = golem_core_types.MakeResultValuePayloadErrValue(option408)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeResultValue(variant409)
+
+						case 23:
+							value410 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option412 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option412 = witTypes.None[string]()
+							case 1:
+								value411 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option412 = witTypes.Some[string](value411)
+							default:
+								panic("unreachable")
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value410, option412})
+
+						case 24:
+							value413 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option415 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option415 = witTypes.None[string]()
+							case 1:
+								value414 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option415 = witTypes.Some[string](value414)
+							default:
+								panic("unreachable")
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value413, option415})
+
+						case 25:
+							value416 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant420 = golem_core_types.MakeSchemaValueNodePathValue(value416)
+
+						case 26:
+							value417 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant420 = golem_core_types.MakeSchemaValueNodeUrlValue(value417)
+
+						case 27:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant420 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value418})
+
+						case 30:
+							value419 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant420 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value419, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result421 = append(result421, variant420)
+					}
+
+					option422 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result393, result397, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 7*4)))}, golem_core_types.SchemaValueTree{result421, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 10*4)))}})
+				default:
+					panic("unreachable")
+				}
+				var variant425 WrappedFunctionType
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 10*4)))) {
+				case 0:
+
+					variant425 = MakeWrappedFunctionTypeReadLocal()
+
+				case 1:
+
+					variant425 = MakeWrappedFunctionTypeWriteLocal()
+
+				case 2:
+
+					variant425 = MakeWrappedFunctionTypeReadRemote()
+
+				case 3:
+
+					variant425 = MakeWrappedFunctionTypeWriteRemote()
+
+				case 4:
+					var option423 witTypes.Option[uint64]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) {
+					case 0:
+
+						option423 = witTypes.None[uint64]()
+					case 1:
+
+						option423 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 10*4)))))
+					default:
+						panic("unreachable")
+					}
+
+					variant425 = MakeWrappedFunctionTypeWriteRemoteBatched(option423)
+
+				case 5:
+					var option424 witTypes.Option[uint64]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) {
+					case 0:
+
+						option424 = witTypes.None[uint64]()
+					case 1:
+
+						option424 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 10*4)))))
+					default:
+						panic("unreachable")
+					}
+
+					variant425 = MakeWrappedFunctionTypeWriteRemoteTransaction(option424)
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryStart(StartParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, option216, value217, option422, variant425})
+
+			case 2:
+				var option630 witTypes.Option[golem_core_types.TypedSchemaValue]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+				case 0:
+
+					option630 = witTypes.None[golem_core_types.TypedSchemaValue]()
+				case 1:
+					result601 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))), index*(56+22*4))
+						var variant589 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option432 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option432 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option427 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option427 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant426 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant426 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant426 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant426 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option427 = witTypes.Some[golem_core_types.NumericBound](variant426)
+								default:
+									panic("unreachable")
+								}
+								var option429 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option429 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant428 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant428 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant428 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant428 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option429 = witTypes.Some[golem_core_types.NumericBound](variant428)
+								default:
+									panic("unreachable")
+								}
+								var option431 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option431 = witTypes.None[string]()
+								case 1:
+									value430 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option431 = witTypes.Some[string](value430)
+								default:
+									panic("unreachable")
+								}
+
+								option432 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option427, option429, option431})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyS8Type(option432)
+
+						case 3:
+							var option439 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option439 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option434 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option434 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant433 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant433 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant433 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant433 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option434 = witTypes.Some[golem_core_types.NumericBound](variant433)
+								default:
+									panic("unreachable")
+								}
+								var option436 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option436 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant435 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant435 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant435 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant435 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option436 = witTypes.Some[golem_core_types.NumericBound](variant435)
+								default:
+									panic("unreachable")
+								}
+								var option438 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option438 = witTypes.None[string]()
+								case 1:
+									value437 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option438 = witTypes.Some[string](value437)
+								default:
+									panic("unreachable")
+								}
+
+								option439 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option434, option436, option438})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyS16Type(option439)
+
+						case 4:
+							var option446 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option446 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option441 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option441 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant440 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant440 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant440 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant440 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option441 = witTypes.Some[golem_core_types.NumericBound](variant440)
+								default:
+									panic("unreachable")
+								}
+								var option443 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option443 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant442 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant442 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant442 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant442 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option443 = witTypes.Some[golem_core_types.NumericBound](variant442)
+								default:
+									panic("unreachable")
+								}
+								var option445 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option445 = witTypes.None[string]()
+								case 1:
+									value444 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option445 = witTypes.Some[string](value444)
+								default:
+									panic("unreachable")
+								}
+
+								option446 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option441, option443, option445})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyS32Type(option446)
+
+						case 5:
+							var option453 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option453 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option448 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option448 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant447 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant447 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant447 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant447 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option448 = witTypes.Some[golem_core_types.NumericBound](variant447)
+								default:
+									panic("unreachable")
+								}
+								var option450 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option450 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant449 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant449 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant449 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant449 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option450 = witTypes.Some[golem_core_types.NumericBound](variant449)
+								default:
+									panic("unreachable")
+								}
+								var option452 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option452 = witTypes.None[string]()
+								case 1:
+									value451 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option452 = witTypes.Some[string](value451)
+								default:
+									panic("unreachable")
+								}
+
+								option453 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option448, option450, option452})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyS64Type(option453)
+
+						case 6:
+							var option460 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option460 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option455 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option455 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant454 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant454 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant454 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant454 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option455 = witTypes.Some[golem_core_types.NumericBound](variant454)
+								default:
+									panic("unreachable")
+								}
+								var option457 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option457 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant456 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant456 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant456 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant456 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option457 = witTypes.Some[golem_core_types.NumericBound](variant456)
+								default:
+									panic("unreachable")
+								}
+								var option459 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option459 = witTypes.None[string]()
+								case 1:
+									value458 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option459 = witTypes.Some[string](value458)
+								default:
+									panic("unreachable")
+								}
+
+								option460 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option455, option457, option459})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyU8Type(option460)
+
+						case 7:
+							var option467 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option467 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option462 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option462 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant461 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant461 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant461 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant461 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option462 = witTypes.Some[golem_core_types.NumericBound](variant461)
+								default:
+									panic("unreachable")
+								}
+								var option464 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option464 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant463 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant463 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant463 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant463 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option464 = witTypes.Some[golem_core_types.NumericBound](variant463)
+								default:
+									panic("unreachable")
+								}
+								var option466 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option466 = witTypes.None[string]()
+								case 1:
+									value465 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option466 = witTypes.Some[string](value465)
+								default:
+									panic("unreachable")
+								}
+
+								option467 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option462, option464, option466})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyU16Type(option467)
+
+						case 8:
+							var option474 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option474 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option469 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option469 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant468 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant468 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant468 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant468 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option469 = witTypes.Some[golem_core_types.NumericBound](variant468)
+								default:
+									panic("unreachable")
+								}
+								var option471 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option471 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant470 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant470 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant470 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant470 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option471 = witTypes.Some[golem_core_types.NumericBound](variant470)
+								default:
+									panic("unreachable")
+								}
+								var option473 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option473 = witTypes.None[string]()
+								case 1:
+									value472 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option473 = witTypes.Some[string](value472)
+								default:
+									panic("unreachable")
+								}
+
+								option474 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option469, option471, option473})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyU32Type(option474)
+
+						case 9:
+							var option481 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option481 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option476 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option476 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant475 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant475 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant475 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant475 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option476 = witTypes.Some[golem_core_types.NumericBound](variant475)
+								default:
+									panic("unreachable")
+								}
+								var option478 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option478 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant477 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant477 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant477 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant477 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option478 = witTypes.Some[golem_core_types.NumericBound](variant477)
+								default:
+									panic("unreachable")
+								}
+								var option480 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option480 = witTypes.None[string]()
+								case 1:
+									value479 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option480 = witTypes.Some[string](value479)
+								default:
+									panic("unreachable")
+								}
+
+								option481 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option476, option478, option480})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyU64Type(option481)
+
+						case 10:
+							var option488 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option488 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option483 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option483 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant482 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant482 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant482 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant482 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option483 = witTypes.Some[golem_core_types.NumericBound](variant482)
+								default:
+									panic("unreachable")
+								}
+								var option485 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option485 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant484 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant484 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant484 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant484 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option485 = witTypes.Some[golem_core_types.NumericBound](variant484)
+								default:
+									panic("unreachable")
+								}
+								var option487 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option487 = witTypes.None[string]()
+								case 1:
+									value486 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option487 = witTypes.Some[string](value486)
+								default:
+									panic("unreachable")
+								}
+
+								option488 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option483, option485, option487})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyF32Type(option488)
+
+						case 11:
+							var option495 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option495 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option490 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option490 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant489 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant489 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant489 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant489 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option490 = witTypes.Some[golem_core_types.NumericBound](variant489)
+								default:
+									panic("unreachable")
+								}
+								var option492 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option492 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant491 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant491 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant491 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant491 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option492 = witTypes.Some[golem_core_types.NumericBound](variant491)
+								default:
+									panic("unreachable")
+								}
+								var option494 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option494 = witTypes.None[string]()
+								case 1:
+									value493 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option494 = witTypes.Some[string](value493)
+								default:
+									panic("unreachable")
+								}
+
+								option495 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option490, option492, option494})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyF64Type(option495)
+
+						case 12:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result508 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value496 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option498 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option498 = witTypes.None[string]()
+								case 1:
+									value497 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option498 = witTypes.Some[string](value497)
+								default:
+									panic("unreachable")
+								}
+								result500 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value499 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result500 = append(result500, value499)
+								}
+
+								result502 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value501 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result502 = append(result502, value501)
+								}
+
+								var option504 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option504 = witTypes.None[string]()
+								case 1:
+									value503 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option504 = witTypes.Some[string](value503)
+								default:
+									panic("unreachable")
+								}
+								var option507 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option507 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant506 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant506 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant506 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant506 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value505 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant506 = golem_core_types.MakeRoleOther(value505)
+
+									default:
+										panic("unreachable")
+									}
+
+									option507 = witTypes.Some[golem_core_types.Role](variant506)
+								default:
+									panic("unreachable")
+								}
+
+								result508 = append(result508, golem_core_types.NamedFieldType{value496, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option498, result500, result502, option504, option507}})
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyRecordType(result508)
+
+						case 15:
+							result522 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value509 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option510 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option510 = witTypes.None[int32]()
+								case 1:
+
+									option510 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option512 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option512 = witTypes.None[string]()
+								case 1:
+									value511 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option512 = witTypes.Some[string](value511)
+								default:
+									panic("unreachable")
+								}
+								result514 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value513 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result514 = append(result514, value513)
+								}
+
+								result516 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value515 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result516 = append(result516, value515)
+								}
+
+								var option518 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option518 = witTypes.None[string]()
+								case 1:
+									value517 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option518 = witTypes.Some[string](value517)
+								default:
+									panic("unreachable")
+								}
+								var option521 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option521 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant520 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant520 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant520 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant520 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value519 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant520 = golem_core_types.MakeRoleOther(value519)
+
+									default:
+										panic("unreachable")
+									}
+
+									option521 = witTypes.Some[golem_core_types.Role](variant520)
+								default:
+									panic("unreachable")
+								}
+
+								result522 = append(result522, golem_core_types.VariantCaseType{value509, option510, golem_core_types.MetadataEnvelope{option512, result514, result516, option518, option521}})
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyVariantType(result522)
+
+						case 16:
+							result524 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value523 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result524 = append(result524, value523)
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyEnumType(result524)
+
+						case 17:
+							result526 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value525 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result526 = append(result526, value525)
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyFlagsType(result526)
+
+						case 18:
+							result527 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result527 = append(result527, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyTupleType(result527)
+
+						case 19:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option528 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option528 = witTypes.None[int32]()
+							case 1:
+
+								option528 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option529 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option529 = witTypes.None[int32]()
+							case 1:
+
+								option529 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option528, option529})
+
+						case 24:
+							var option532 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option532 = witTypes.None[[]string]()
+							case 1:
+								result531 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value530 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result531 = append(result531, value530)
+								}
+
+								option532 = witTypes.Some[[]string](result531)
+							default:
+								panic("unreachable")
+							}
+							var option533 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option533 = witTypes.None[uint32]()
+							case 1:
+
+								option533 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option534 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option534 = witTypes.None[uint32]()
+							case 1:
+
+								option534 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option536 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option536 = witTypes.None[string]()
+							case 1:
+								value535 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option536 = witTypes.Some[string](value535)
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option532, option533, option534, option536})
+
+						case 25:
+							var option539 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option539 = witTypes.None[[]string]()
+							case 1:
+								result538 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value537 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result538 = append(result538, value537)
+								}
+
+								option539 = witTypes.Some[[]string](result538)
+							default:
+								panic("unreachable")
+							}
+							var option540 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option540 = witTypes.None[uint32]()
+							case 1:
+
+								option540 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option541 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option541 = witTypes.None[uint32]()
+							case 1:
+
+								option541 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option539, option540, option541})
+
+						case 26:
+							var option544 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option544 = witTypes.None[[]string]()
+							case 1:
+								result543 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value542 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result543 = append(result543, value542)
+								}
+
+								option544 = witTypes.Some[[]string](result543)
+							default:
+								panic("unreachable")
+							}
+							var option547 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option547 = witTypes.None[[]string]()
+							case 1:
+								result546 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value545 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result546 = append(result546, value545)
+								}
+
+								option547 = witTypes.Some[[]string](result546)
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option544, option547})
+
+						case 27:
+							var option550 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option550 = witTypes.None[[]string]()
+							case 1:
+								result549 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value548 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result549 = append(result549, value548)
+								}
+
+								option550 = witTypes.Some[[]string](result549)
+							default:
+								panic("unreachable")
+							}
+							var option553 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option553 = witTypes.None[[]string]()
+							case 1:
+								result552 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value551 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result552 = append(result552, value551)
+								}
+
+								option553 = witTypes.Some[[]string](result552)
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option550, option553})
+
+						case 28:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value554 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result556 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value555 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result556 = append(result556, value555)
+							}
+
+							var option558 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option558 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value557 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option558 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value557})
+							default:
+								panic("unreachable")
+							}
+							var option560 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option560 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value559 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option560 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value559})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value554, result556, option558, option560})
+
+						case 31:
+							result582 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value561 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant570 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value562 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant570 = golem_core_types.MakeDiscriminatorRulePrefix(value562)
+
+								case 1:
+									value563 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant570 = golem_core_types.MakeDiscriminatorRuleSuffix(value563)
+
+								case 2:
+									value564 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant570 = golem_core_types.MakeDiscriminatorRuleContains(value564)
+
+								case 3:
+									value565 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant570 = golem_core_types.MakeDiscriminatorRuleRegex(value565)
+
+								case 4:
+									value566 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option568 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option568 = witTypes.None[string]()
+									case 1:
+										value567 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option568 = witTypes.Some[string](value567)
+									default:
+										panic("unreachable")
+									}
+
+									variant570 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value566, option568})
+
+								case 5:
+									value569 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant570 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value569)
+
+								default:
+									panic("unreachable")
+								}
+								var option572 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option572 = witTypes.None[string]()
+								case 1:
+									value571 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option572 = witTypes.Some[string](value571)
+								default:
+									panic("unreachable")
+								}
+								result574 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value573 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result574 = append(result574, value573)
+								}
+
+								result576 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value575 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result576 = append(result576, value575)
+								}
+
+								var option578 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option578 = witTypes.None[string]()
+								case 1:
+									value577 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option578 = witTypes.Some[string](value577)
+								default:
+									panic("unreachable")
+								}
+								var option581 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option581 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant580 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant580 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant580 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant580 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value579 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant580 = golem_core_types.MakeRoleOther(value579)
+
+									default:
+										panic("unreachable")
+									}
+
+									option581 = witTypes.Some[golem_core_types.Role](variant580)
+								default:
+									panic("unreachable")
+								}
+
+								result582 = append(result582, golem_core_types.UnionBranch{value561, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant570, golem_core_types.MetadataEnvelope{option572, result574, result576, option578, option581}})
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result582})
+
+						case 32:
+							var option584 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option584 = witTypes.None[string]()
+							case 1:
+								value583 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option584 = witTypes.Some[string](value583)
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option584})
+
+						case 33:
+							var option586 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option586 = witTypes.None[string]()
+							case 1:
+								value585 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option586 = witTypes.Some[string](value585)
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option586})
+
+						case 34:
+							var option587 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option587 = witTypes.None[int32]()
+							case 1:
+
+								option587 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyFutureType(option587)
+
+						case 35:
+							var option588 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option588 = witTypes.None[int32]()
+							case 1:
+
+								option588 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyStreamType(option588)
+
+						default:
+							panic("unreachable")
+						}
+						var option591 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option591 = witTypes.None[string]()
+						case 1:
+							value590 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option591 = witTypes.Some[string](value590)
+						default:
+							panic("unreachable")
+						}
+						result593 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value592 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result593 = append(result593, value592)
+						}
+
+						result595 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value594 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result595 = append(result595, value594)
+						}
+
+						var option597 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option597 = witTypes.None[string]()
+						case 1:
+							value596 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option597 = witTypes.Some[string](value596)
+						default:
+							panic("unreachable")
+						}
+						var option600 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option600 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant599 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant599 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant599 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant599 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value598 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant599 = golem_core_types.MakeRoleOther(value598)
+
+							default:
+								panic("unreachable")
+							}
+
+							option600 = witTypes.Some[golem_core_types.Role](variant599)
+						default:
+							panic("unreachable")
+						}
+
+						result601 = append(result601, golem_core_types.SchemaTypeNode{variant589, golem_core_types.MetadataEnvelope{option591, result593, result595, option597, option600}})
+					}
+
+					result605 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))), index*(6*4))
+						value602 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option604 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option604 = witTypes.None[string]()
+						case 1:
+							value603 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option604 = witTypes.Some[string](value603)
+						default:
+							panic("unreachable")
+						}
+
+						result605 = append(result605, golem_core_types.SchemaTypeDef{value602, option604, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result629 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))))), index*(16+4*4))
+						var variant628 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value606 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant628 = golem_core_types.MakeSchemaValueNodeStringValue(value606)
+
+						case 13:
+							result607 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result607 = append(result607, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeRecordValue(result607)
+
+						case 14:
+							var option608 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option608 = witTypes.None[int32]()
+							case 1:
+
+								option608 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option608})
+
+						case 15:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result609 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result609 = append(result609, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeFlagsValue(result609)
+
+						case 17:
+							result610 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result610 = append(result610, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeTupleValue(result610)
+
+						case 18:
+							result611 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result611 = append(result611, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeListValue(result611)
+
+						case 19:
+							result612 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result612 = append(result612, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeFixedListValue(result612)
+
+						case 20:
+							result613 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result613 = append(result613, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeMapValue(result613)
+
+						case 21:
+							var option614 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option614 = witTypes.None[int32]()
+							case 1:
+
+								option614 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeOptionValue(option614)
+
+						case 22:
+							var variant617 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option615 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option615 = witTypes.None[int32]()
+								case 1:
+
+									option615 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant617 = golem_core_types.MakeResultValuePayloadOkValue(option615)
+
+							case 1:
+								var option616 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option616 = witTypes.None[int32]()
+								case 1:
+
+									option616 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant617 = golem_core_types.MakeResultValuePayloadErrValue(option616)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeResultValue(variant617)
+
+						case 23:
+							value618 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option620 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option620 = witTypes.None[string]()
+							case 1:
+								value619 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option620 = witTypes.Some[string](value619)
+							default:
+								panic("unreachable")
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value618, option620})
+
+						case 24:
+							value621 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option623 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option623 = witTypes.None[string]()
+							case 1:
+								value622 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option623 = witTypes.Some[string](value622)
+							default:
+								panic("unreachable")
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value621, option623})
+
+						case 25:
+							value624 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant628 = golem_core_types.MakeSchemaValueNodePathValue(value624)
+
+						case 26:
+							value625 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant628 = golem_core_types.MakeSchemaValueNodeUrlValue(value625)
+
+						case 27:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value626 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant628 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value626})
+
+						case 30:
+							value627 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant628 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value627, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result629 = append(result629, variant628)
+					}
+
+					option630 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result601, result605, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result629, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}})
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryEnd(EndParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), option630, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4)))) != 0)})
+
+			case 3:
+				var option835 witTypes.Option[golem_core_types.TypedSchemaValue]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+				case 0:
+
+					option835 = witTypes.None[golem_core_types.TypedSchemaValue]()
+				case 1:
+					result806 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))), index*(56+22*4))
+						var variant794 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option637 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option637 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option632 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option632 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant631 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant631 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant631 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant631 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option632 = witTypes.Some[golem_core_types.NumericBound](variant631)
+								default:
+									panic("unreachable")
+								}
+								var option634 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option634 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant633 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant633 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant633 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant633 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option634 = witTypes.Some[golem_core_types.NumericBound](variant633)
+								default:
+									panic("unreachable")
+								}
+								var option636 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option636 = witTypes.None[string]()
+								case 1:
+									value635 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option636 = witTypes.Some[string](value635)
+								default:
+									panic("unreachable")
+								}
+
+								option637 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option632, option634, option636})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyS8Type(option637)
+
+						case 3:
+							var option644 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option644 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option639 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option639 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant638 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant638 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant638 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant638 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option639 = witTypes.Some[golem_core_types.NumericBound](variant638)
+								default:
+									panic("unreachable")
+								}
+								var option641 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option641 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant640 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant640 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant640 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant640 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option641 = witTypes.Some[golem_core_types.NumericBound](variant640)
+								default:
+									panic("unreachable")
+								}
+								var option643 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option643 = witTypes.None[string]()
+								case 1:
+									value642 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option643 = witTypes.Some[string](value642)
+								default:
+									panic("unreachable")
+								}
+
+								option644 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option639, option641, option643})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyS16Type(option644)
+
+						case 4:
+							var option651 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option651 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option646 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option646 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant645 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant645 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant645 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant645 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option646 = witTypes.Some[golem_core_types.NumericBound](variant645)
+								default:
+									panic("unreachable")
+								}
+								var option648 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option648 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant647 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant647 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant647 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant647 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option648 = witTypes.Some[golem_core_types.NumericBound](variant647)
+								default:
+									panic("unreachable")
+								}
+								var option650 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option650 = witTypes.None[string]()
+								case 1:
+									value649 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option650 = witTypes.Some[string](value649)
+								default:
+									panic("unreachable")
+								}
+
+								option651 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option646, option648, option650})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyS32Type(option651)
+
+						case 5:
+							var option658 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option658 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option653 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option653 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant652 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant652 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant652 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant652 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option653 = witTypes.Some[golem_core_types.NumericBound](variant652)
+								default:
+									panic("unreachable")
+								}
+								var option655 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option655 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant654 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant654 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant654 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant654 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option655 = witTypes.Some[golem_core_types.NumericBound](variant654)
+								default:
+									panic("unreachable")
+								}
+								var option657 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option657 = witTypes.None[string]()
+								case 1:
+									value656 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option657 = witTypes.Some[string](value656)
+								default:
+									panic("unreachable")
+								}
+
+								option658 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option653, option655, option657})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyS64Type(option658)
+
+						case 6:
+							var option665 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option665 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option660 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option660 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant659 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant659 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant659 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant659 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option660 = witTypes.Some[golem_core_types.NumericBound](variant659)
+								default:
+									panic("unreachable")
+								}
+								var option662 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option662 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant661 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant661 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant661 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant661 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option662 = witTypes.Some[golem_core_types.NumericBound](variant661)
+								default:
+									panic("unreachable")
+								}
+								var option664 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option664 = witTypes.None[string]()
+								case 1:
+									value663 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option664 = witTypes.Some[string](value663)
+								default:
+									panic("unreachable")
+								}
+
+								option665 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option660, option662, option664})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyU8Type(option665)
+
+						case 7:
+							var option672 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option672 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option667 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option667 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant666 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant666 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant666 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant666 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option667 = witTypes.Some[golem_core_types.NumericBound](variant666)
+								default:
+									panic("unreachable")
+								}
+								var option669 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option669 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant668 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant668 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant668 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant668 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option669 = witTypes.Some[golem_core_types.NumericBound](variant668)
+								default:
+									panic("unreachable")
+								}
+								var option671 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option671 = witTypes.None[string]()
+								case 1:
+									value670 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option671 = witTypes.Some[string](value670)
+								default:
+									panic("unreachable")
+								}
+
+								option672 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option667, option669, option671})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyU16Type(option672)
+
+						case 8:
+							var option679 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option679 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option674 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option674 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant673 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant673 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant673 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant673 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option674 = witTypes.Some[golem_core_types.NumericBound](variant673)
+								default:
+									panic("unreachable")
+								}
+								var option676 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option676 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant675 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant675 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant675 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant675 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option676 = witTypes.Some[golem_core_types.NumericBound](variant675)
+								default:
+									panic("unreachable")
+								}
+								var option678 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option678 = witTypes.None[string]()
+								case 1:
+									value677 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option678 = witTypes.Some[string](value677)
+								default:
+									panic("unreachable")
+								}
+
+								option679 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option674, option676, option678})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyU32Type(option679)
+
+						case 9:
+							var option686 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option686 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option681 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option681 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant680 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant680 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant680 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant680 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option681 = witTypes.Some[golem_core_types.NumericBound](variant680)
+								default:
+									panic("unreachable")
+								}
+								var option683 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option683 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant682 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant682 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant682 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant682 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option683 = witTypes.Some[golem_core_types.NumericBound](variant682)
+								default:
+									panic("unreachable")
+								}
+								var option685 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option685 = witTypes.None[string]()
+								case 1:
+									value684 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option685 = witTypes.Some[string](value684)
+								default:
+									panic("unreachable")
+								}
+
+								option686 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option681, option683, option685})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyU64Type(option686)
+
+						case 10:
+							var option693 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option693 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option688 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option688 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant687 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant687 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant687 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant687 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option688 = witTypes.Some[golem_core_types.NumericBound](variant687)
+								default:
+									panic("unreachable")
+								}
+								var option690 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option690 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant689 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant689 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant689 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant689 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option690 = witTypes.Some[golem_core_types.NumericBound](variant689)
+								default:
+									panic("unreachable")
+								}
+								var option692 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option692 = witTypes.None[string]()
+								case 1:
+									value691 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option692 = witTypes.Some[string](value691)
+								default:
+									panic("unreachable")
+								}
+
+								option693 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option688, option690, option692})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyF32Type(option693)
+
+						case 11:
+							var option700 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option700 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option695 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option695 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant694 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant694 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant694 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant694 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option695 = witTypes.Some[golem_core_types.NumericBound](variant694)
+								default:
+									panic("unreachable")
+								}
+								var option697 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option697 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant696 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant696 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant696 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant696 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option697 = witTypes.Some[golem_core_types.NumericBound](variant696)
+								default:
+									panic("unreachable")
+								}
+								var option699 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option699 = witTypes.None[string]()
+								case 1:
+									value698 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option699 = witTypes.Some[string](value698)
+								default:
+									panic("unreachable")
+								}
+
+								option700 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option695, option697, option699})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyF64Type(option700)
+
+						case 12:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result713 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value701 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option703 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option703 = witTypes.None[string]()
+								case 1:
+									value702 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option703 = witTypes.Some[string](value702)
+								default:
+									panic("unreachable")
+								}
+								result705 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value704 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result705 = append(result705, value704)
+								}
+
+								result707 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value706 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result707 = append(result707, value706)
+								}
+
+								var option709 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option709 = witTypes.None[string]()
+								case 1:
+									value708 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option709 = witTypes.Some[string](value708)
+								default:
+									panic("unreachable")
+								}
+								var option712 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option712 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant711 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant711 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant711 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant711 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value710 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant711 = golem_core_types.MakeRoleOther(value710)
+
+									default:
+										panic("unreachable")
+									}
+
+									option712 = witTypes.Some[golem_core_types.Role](variant711)
+								default:
+									panic("unreachable")
+								}
+
+								result713 = append(result713, golem_core_types.NamedFieldType{value701, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option703, result705, result707, option709, option712}})
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyRecordType(result713)
+
+						case 15:
+							result727 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value714 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option715 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option715 = witTypes.None[int32]()
+								case 1:
+
+									option715 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option717 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option717 = witTypes.None[string]()
+								case 1:
+									value716 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option717 = witTypes.Some[string](value716)
+								default:
+									panic("unreachable")
+								}
+								result719 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value718 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result719 = append(result719, value718)
+								}
+
+								result721 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value720 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result721 = append(result721, value720)
+								}
+
+								var option723 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option723 = witTypes.None[string]()
+								case 1:
+									value722 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option723 = witTypes.Some[string](value722)
+								default:
+									panic("unreachable")
+								}
+								var option726 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option726 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant725 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant725 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant725 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant725 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value724 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant725 = golem_core_types.MakeRoleOther(value724)
+
+									default:
+										panic("unreachable")
+									}
+
+									option726 = witTypes.Some[golem_core_types.Role](variant725)
+								default:
+									panic("unreachable")
+								}
+
+								result727 = append(result727, golem_core_types.VariantCaseType{value714, option715, golem_core_types.MetadataEnvelope{option717, result719, result721, option723, option726}})
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyVariantType(result727)
+
+						case 16:
+							result729 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value728 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result729 = append(result729, value728)
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyEnumType(result729)
+
+						case 17:
+							result731 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value730 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result731 = append(result731, value730)
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyFlagsType(result731)
+
+						case 18:
+							result732 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result732 = append(result732, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyTupleType(result732)
+
+						case 19:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option733 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option733 = witTypes.None[int32]()
+							case 1:
+
+								option733 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option734 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option734 = witTypes.None[int32]()
+							case 1:
+
+								option734 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option733, option734})
+
+						case 24:
+							var option737 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option737 = witTypes.None[[]string]()
+							case 1:
+								result736 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value735 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result736 = append(result736, value735)
+								}
+
+								option737 = witTypes.Some[[]string](result736)
+							default:
+								panic("unreachable")
+							}
+							var option738 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option738 = witTypes.None[uint32]()
+							case 1:
+
+								option738 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option739 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option739 = witTypes.None[uint32]()
+							case 1:
+
+								option739 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option741 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option741 = witTypes.None[string]()
+							case 1:
+								value740 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option741 = witTypes.Some[string](value740)
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option737, option738, option739, option741})
+
+						case 25:
+							var option744 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option744 = witTypes.None[[]string]()
+							case 1:
+								result743 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value742 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result743 = append(result743, value742)
+								}
+
+								option744 = witTypes.Some[[]string](result743)
+							default:
+								panic("unreachable")
+							}
+							var option745 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option745 = witTypes.None[uint32]()
+							case 1:
+
+								option745 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option746 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option746 = witTypes.None[uint32]()
+							case 1:
+
+								option746 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option744, option745, option746})
+
+						case 26:
+							var option749 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option749 = witTypes.None[[]string]()
+							case 1:
+								result748 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value747 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result748 = append(result748, value747)
+								}
+
+								option749 = witTypes.Some[[]string](result748)
+							default:
+								panic("unreachable")
+							}
+							var option752 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option752 = witTypes.None[[]string]()
+							case 1:
+								result751 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value750 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result751 = append(result751, value750)
+								}
+
+								option752 = witTypes.Some[[]string](result751)
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option749, option752})
+
+						case 27:
+							var option755 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option755 = witTypes.None[[]string]()
+							case 1:
+								result754 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value753 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result754 = append(result754, value753)
+								}
+
+								option755 = witTypes.Some[[]string](result754)
+							default:
+								panic("unreachable")
+							}
+							var option758 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option758 = witTypes.None[[]string]()
+							case 1:
+								result757 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value756 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result757 = append(result757, value756)
+								}
+
+								option758 = witTypes.Some[[]string](result757)
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option755, option758})
+
+						case 28:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value759 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result761 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value760 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result761 = append(result761, value760)
+							}
+
+							var option763 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option763 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value762 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option763 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value762})
+							default:
+								panic("unreachable")
+							}
+							var option765 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option765 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value764 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option765 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value764})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value759, result761, option763, option765})
+
+						case 31:
+							result787 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value766 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant775 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value767 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant775 = golem_core_types.MakeDiscriminatorRulePrefix(value767)
+
+								case 1:
+									value768 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant775 = golem_core_types.MakeDiscriminatorRuleSuffix(value768)
+
+								case 2:
+									value769 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant775 = golem_core_types.MakeDiscriminatorRuleContains(value769)
+
+								case 3:
+									value770 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant775 = golem_core_types.MakeDiscriminatorRuleRegex(value770)
+
+								case 4:
+									value771 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option773 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option773 = witTypes.None[string]()
+									case 1:
+										value772 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option773 = witTypes.Some[string](value772)
+									default:
+										panic("unreachable")
+									}
+
+									variant775 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value771, option773})
+
+								case 5:
+									value774 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant775 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value774)
+
+								default:
+									panic("unreachable")
+								}
+								var option777 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option777 = witTypes.None[string]()
+								case 1:
+									value776 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option777 = witTypes.Some[string](value776)
+								default:
+									panic("unreachable")
+								}
+								result779 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value778 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result779 = append(result779, value778)
+								}
+
+								result781 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value780 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result781 = append(result781, value780)
+								}
+
+								var option783 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option783 = witTypes.None[string]()
+								case 1:
+									value782 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option783 = witTypes.Some[string](value782)
+								default:
+									panic("unreachable")
+								}
+								var option786 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option786 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant785 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant785 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant785 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant785 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value784 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant785 = golem_core_types.MakeRoleOther(value784)
+
+									default:
+										panic("unreachable")
+									}
+
+									option786 = witTypes.Some[golem_core_types.Role](variant785)
+								default:
+									panic("unreachable")
+								}
+
+								result787 = append(result787, golem_core_types.UnionBranch{value766, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant775, golem_core_types.MetadataEnvelope{option777, result779, result781, option783, option786}})
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result787})
+
+						case 32:
+							var option789 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option789 = witTypes.None[string]()
+							case 1:
+								value788 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option789 = witTypes.Some[string](value788)
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option789})
+
+						case 33:
+							var option791 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option791 = witTypes.None[string]()
+							case 1:
+								value790 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option791 = witTypes.Some[string](value790)
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option791})
+
+						case 34:
+							var option792 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option792 = witTypes.None[int32]()
+							case 1:
+
+								option792 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyFutureType(option792)
+
+						case 35:
+							var option793 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option793 = witTypes.None[int32]()
+							case 1:
+
+								option793 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyStreamType(option793)
+
+						default:
+							panic("unreachable")
+						}
+						var option796 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option796 = witTypes.None[string]()
+						case 1:
+							value795 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option796 = witTypes.Some[string](value795)
+						default:
+							panic("unreachable")
+						}
+						result798 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value797 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result798 = append(result798, value797)
+						}
+
+						result800 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value799 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result800 = append(result800, value799)
+						}
+
+						var option802 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option802 = witTypes.None[string]()
+						case 1:
+							value801 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option802 = witTypes.Some[string](value801)
+						default:
+							panic("unreachable")
+						}
+						var option805 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option805 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant804 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant804 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant804 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant804 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value803 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant804 = golem_core_types.MakeRoleOther(value803)
+
+							default:
+								panic("unreachable")
+							}
+
+							option805 = witTypes.Some[golem_core_types.Role](variant804)
+						default:
+							panic("unreachable")
+						}
+
+						result806 = append(result806, golem_core_types.SchemaTypeNode{variant794, golem_core_types.MetadataEnvelope{option796, result798, result800, option802, option805}})
+					}
+
+					result810 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))), index*(6*4))
+						value807 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option809 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option809 = witTypes.None[string]()
+						case 1:
+							value808 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option809 = witTypes.Some[string](value808)
+						default:
+							panic("unreachable")
+						}
+
+						result810 = append(result810, golem_core_types.SchemaTypeDef{value807, option809, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result834 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))))), index*(16+4*4))
+						var variant833 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value811 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant833 = golem_core_types.MakeSchemaValueNodeStringValue(value811)
+
+						case 13:
+							result812 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result812 = append(result812, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeRecordValue(result812)
+
+						case 14:
+							var option813 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option813 = witTypes.None[int32]()
+							case 1:
+
+								option813 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option813})
+
+						case 15:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result814 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result814 = append(result814, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeFlagsValue(result814)
+
+						case 17:
+							result815 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result815 = append(result815, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeTupleValue(result815)
+
+						case 18:
+							result816 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result816 = append(result816, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeListValue(result816)
+
+						case 19:
+							result817 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result817 = append(result817, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeFixedListValue(result817)
+
+						case 20:
+							result818 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result818 = append(result818, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeMapValue(result818)
+
+						case 21:
+							var option819 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option819 = witTypes.None[int32]()
+							case 1:
+
+								option819 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeOptionValue(option819)
+
+						case 22:
+							var variant822 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option820 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option820 = witTypes.None[int32]()
+								case 1:
+
+									option820 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant822 = golem_core_types.MakeResultValuePayloadOkValue(option820)
+
+							case 1:
+								var option821 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option821 = witTypes.None[int32]()
+								case 1:
+
+									option821 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant822 = golem_core_types.MakeResultValuePayloadErrValue(option821)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeResultValue(variant822)
+
+						case 23:
+							value823 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option825 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option825 = witTypes.None[string]()
+							case 1:
+								value824 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option825 = witTypes.Some[string](value824)
+							default:
+								panic("unreachable")
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value823, option825})
+
+						case 24:
+							value826 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option828 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option828 = witTypes.None[string]()
+							case 1:
+								value827 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option828 = witTypes.Some[string](value827)
+							default:
+								panic("unreachable")
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value826, option828})
+
+						case 25:
+							value829 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant833 = golem_core_types.MakeSchemaValueNodePathValue(value829)
+
+						case 26:
+							value830 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant833 = golem_core_types.MakeSchemaValueNodeUrlValue(value830)
+
+						case 27:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value831 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant833 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value831})
+
+						case 30:
+							value832 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant833 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value832, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result834 = append(result834, variant833)
+					}
+
+					option835 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result806, result810, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result834, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}})
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryCancelled(CancelledParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), option835})
+
+			case 4:
+				var variant1280 AgentInvocation
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+				case 0:
+					value836 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+					result1012 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))), index*(56+22*4))
+						var variant1000 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option843 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option843 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option838 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option838 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant837 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant837 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant837 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant837 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option838 = witTypes.Some[golem_core_types.NumericBound](variant837)
+								default:
+									panic("unreachable")
+								}
+								var option840 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option840 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant839 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant839 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant839 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant839 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option840 = witTypes.Some[golem_core_types.NumericBound](variant839)
+								default:
+									panic("unreachable")
+								}
+								var option842 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option842 = witTypes.None[string]()
+								case 1:
+									value841 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option842 = witTypes.Some[string](value841)
+								default:
+									panic("unreachable")
+								}
+
+								option843 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option838, option840, option842})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyS8Type(option843)
+
+						case 3:
+							var option850 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option850 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option845 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option845 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant844 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant844 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant844 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant844 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option845 = witTypes.Some[golem_core_types.NumericBound](variant844)
+								default:
+									panic("unreachable")
+								}
+								var option847 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option847 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant846 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant846 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant846 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant846 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option847 = witTypes.Some[golem_core_types.NumericBound](variant846)
+								default:
+									panic("unreachable")
+								}
+								var option849 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option849 = witTypes.None[string]()
+								case 1:
+									value848 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option849 = witTypes.Some[string](value848)
+								default:
+									panic("unreachable")
+								}
+
+								option850 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option845, option847, option849})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyS16Type(option850)
+
+						case 4:
+							var option857 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option857 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option852 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option852 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant851 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant851 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant851 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant851 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option852 = witTypes.Some[golem_core_types.NumericBound](variant851)
+								default:
+									panic("unreachable")
+								}
+								var option854 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option854 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant853 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant853 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant853 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant853 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option854 = witTypes.Some[golem_core_types.NumericBound](variant853)
+								default:
+									panic("unreachable")
+								}
+								var option856 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option856 = witTypes.None[string]()
+								case 1:
+									value855 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option856 = witTypes.Some[string](value855)
+								default:
+									panic("unreachable")
+								}
+
+								option857 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option852, option854, option856})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyS32Type(option857)
+
+						case 5:
+							var option864 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option864 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option859 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option859 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant858 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant858 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant858 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant858 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option859 = witTypes.Some[golem_core_types.NumericBound](variant858)
+								default:
+									panic("unreachable")
+								}
+								var option861 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option861 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant860 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant860 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant860 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant860 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option861 = witTypes.Some[golem_core_types.NumericBound](variant860)
+								default:
+									panic("unreachable")
+								}
+								var option863 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option863 = witTypes.None[string]()
+								case 1:
+									value862 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option863 = witTypes.Some[string](value862)
+								default:
+									panic("unreachable")
+								}
+
+								option864 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option859, option861, option863})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyS64Type(option864)
+
+						case 6:
+							var option871 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option871 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option866 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option866 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant865 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant865 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant865 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant865 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option866 = witTypes.Some[golem_core_types.NumericBound](variant865)
+								default:
+									panic("unreachable")
+								}
+								var option868 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option868 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant867 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant867 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant867 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant867 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option868 = witTypes.Some[golem_core_types.NumericBound](variant867)
+								default:
+									panic("unreachable")
+								}
+								var option870 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option870 = witTypes.None[string]()
+								case 1:
+									value869 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option870 = witTypes.Some[string](value869)
+								default:
+									panic("unreachable")
+								}
+
+								option871 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option866, option868, option870})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyU8Type(option871)
+
+						case 7:
+							var option878 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option878 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option873 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option873 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant872 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant872 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant872 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant872 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option873 = witTypes.Some[golem_core_types.NumericBound](variant872)
+								default:
+									panic("unreachable")
+								}
+								var option875 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option875 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant874 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant874 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant874 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant874 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option875 = witTypes.Some[golem_core_types.NumericBound](variant874)
+								default:
+									panic("unreachable")
+								}
+								var option877 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option877 = witTypes.None[string]()
+								case 1:
+									value876 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option877 = witTypes.Some[string](value876)
+								default:
+									panic("unreachable")
+								}
+
+								option878 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option873, option875, option877})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyU16Type(option878)
+
+						case 8:
+							var option885 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option885 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option880 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option880 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant879 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant879 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant879 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant879 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option880 = witTypes.Some[golem_core_types.NumericBound](variant879)
+								default:
+									panic("unreachable")
+								}
+								var option882 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option882 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant881 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant881 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant881 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant881 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option882 = witTypes.Some[golem_core_types.NumericBound](variant881)
+								default:
+									panic("unreachable")
+								}
+								var option884 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option884 = witTypes.None[string]()
+								case 1:
+									value883 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option884 = witTypes.Some[string](value883)
+								default:
+									panic("unreachable")
+								}
+
+								option885 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option880, option882, option884})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyU32Type(option885)
+
+						case 9:
+							var option892 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option892 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option887 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option887 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant886 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant886 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant886 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant886 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option887 = witTypes.Some[golem_core_types.NumericBound](variant886)
+								default:
+									panic("unreachable")
+								}
+								var option889 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option889 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant888 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant888 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant888 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant888 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option889 = witTypes.Some[golem_core_types.NumericBound](variant888)
+								default:
+									panic("unreachable")
+								}
+								var option891 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option891 = witTypes.None[string]()
+								case 1:
+									value890 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option891 = witTypes.Some[string](value890)
+								default:
+									panic("unreachable")
+								}
+
+								option892 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option887, option889, option891})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyU64Type(option892)
+
+						case 10:
+							var option899 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option899 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option894 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option894 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant893 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant893 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant893 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant893 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option894 = witTypes.Some[golem_core_types.NumericBound](variant893)
+								default:
+									panic("unreachable")
+								}
+								var option896 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option896 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant895 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant895 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant895 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant895 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option896 = witTypes.Some[golem_core_types.NumericBound](variant895)
+								default:
+									panic("unreachable")
+								}
+								var option898 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option898 = witTypes.None[string]()
+								case 1:
+									value897 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option898 = witTypes.Some[string](value897)
+								default:
+									panic("unreachable")
+								}
+
+								option899 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option894, option896, option898})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyF32Type(option899)
+
+						case 11:
+							var option906 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option906 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option901 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option901 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant900 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant900 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant900 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant900 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option901 = witTypes.Some[golem_core_types.NumericBound](variant900)
+								default:
+									panic("unreachable")
+								}
+								var option903 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option903 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant902 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant902 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant902 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant902 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option903 = witTypes.Some[golem_core_types.NumericBound](variant902)
+								default:
+									panic("unreachable")
+								}
+								var option905 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option905 = witTypes.None[string]()
+								case 1:
+									value904 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option905 = witTypes.Some[string](value904)
+								default:
+									panic("unreachable")
+								}
+
+								option906 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option901, option903, option905})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyF64Type(option906)
+
+						case 12:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result919 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value907 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option909 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option909 = witTypes.None[string]()
+								case 1:
+									value908 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option909 = witTypes.Some[string](value908)
+								default:
+									panic("unreachable")
+								}
+								result911 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value910 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result911 = append(result911, value910)
+								}
+
+								result913 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value912 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result913 = append(result913, value912)
+								}
+
+								var option915 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option915 = witTypes.None[string]()
+								case 1:
+									value914 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option915 = witTypes.Some[string](value914)
+								default:
+									panic("unreachable")
+								}
+								var option918 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option918 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant917 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant917 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant917 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant917 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value916 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant917 = golem_core_types.MakeRoleOther(value916)
+
+									default:
+										panic("unreachable")
+									}
+
+									option918 = witTypes.Some[golem_core_types.Role](variant917)
+								default:
+									panic("unreachable")
+								}
+
+								result919 = append(result919, golem_core_types.NamedFieldType{value907, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option909, result911, result913, option915, option918}})
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyRecordType(result919)
+
+						case 15:
+							result933 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value920 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option921 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option921 = witTypes.None[int32]()
+								case 1:
+
+									option921 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option923 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option923 = witTypes.None[string]()
+								case 1:
+									value922 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option923 = witTypes.Some[string](value922)
+								default:
+									panic("unreachable")
+								}
+								result925 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value924 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result925 = append(result925, value924)
+								}
+
+								result927 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value926 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result927 = append(result927, value926)
+								}
+
+								var option929 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option929 = witTypes.None[string]()
+								case 1:
+									value928 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option929 = witTypes.Some[string](value928)
+								default:
+									panic("unreachable")
+								}
+								var option932 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option932 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant931 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant931 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant931 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant931 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value930 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant931 = golem_core_types.MakeRoleOther(value930)
+
+									default:
+										panic("unreachable")
+									}
+
+									option932 = witTypes.Some[golem_core_types.Role](variant931)
+								default:
+									panic("unreachable")
+								}
+
+								result933 = append(result933, golem_core_types.VariantCaseType{value920, option921, golem_core_types.MetadataEnvelope{option923, result925, result927, option929, option932}})
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyVariantType(result933)
+
+						case 16:
+							result935 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value934 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result935 = append(result935, value934)
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyEnumType(result935)
+
+						case 17:
+							result937 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value936 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result937 = append(result937, value936)
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyFlagsType(result937)
+
+						case 18:
+							result938 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result938 = append(result938, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyTupleType(result938)
+
+						case 19:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option939 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option939 = witTypes.None[int32]()
+							case 1:
+
+								option939 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option940 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option940 = witTypes.None[int32]()
+							case 1:
+
+								option940 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option939, option940})
+
+						case 24:
+							var option943 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option943 = witTypes.None[[]string]()
+							case 1:
+								result942 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value941 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result942 = append(result942, value941)
+								}
+
+								option943 = witTypes.Some[[]string](result942)
+							default:
+								panic("unreachable")
+							}
+							var option944 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option944 = witTypes.None[uint32]()
+							case 1:
+
+								option944 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option945 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option945 = witTypes.None[uint32]()
+							case 1:
+
+								option945 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option947 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option947 = witTypes.None[string]()
+							case 1:
+								value946 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option947 = witTypes.Some[string](value946)
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option943, option944, option945, option947})
+
+						case 25:
+							var option950 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option950 = witTypes.None[[]string]()
+							case 1:
+								result949 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value948 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result949 = append(result949, value948)
+								}
+
+								option950 = witTypes.Some[[]string](result949)
+							default:
+								panic("unreachable")
+							}
+							var option951 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option951 = witTypes.None[uint32]()
+							case 1:
+
+								option951 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option952 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option952 = witTypes.None[uint32]()
+							case 1:
+
+								option952 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option950, option951, option952})
+
+						case 26:
+							var option955 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option955 = witTypes.None[[]string]()
+							case 1:
+								result954 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value953 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result954 = append(result954, value953)
+								}
+
+								option955 = witTypes.Some[[]string](result954)
+							default:
+								panic("unreachable")
+							}
+							var option958 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option958 = witTypes.None[[]string]()
+							case 1:
+								result957 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value956 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result957 = append(result957, value956)
+								}
+
+								option958 = witTypes.Some[[]string](result957)
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option955, option958})
+
+						case 27:
+							var option961 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option961 = witTypes.None[[]string]()
+							case 1:
+								result960 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value959 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result960 = append(result960, value959)
+								}
+
+								option961 = witTypes.Some[[]string](result960)
+							default:
+								panic("unreachable")
+							}
+							var option964 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option964 = witTypes.None[[]string]()
+							case 1:
+								result963 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value962 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result963 = append(result963, value962)
+								}
+
+								option964 = witTypes.Some[[]string](result963)
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option961, option964})
+
+						case 28:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value965 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result967 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value966 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result967 = append(result967, value966)
+							}
+
+							var option969 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option969 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value968 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option969 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value968})
+							default:
+								panic("unreachable")
+							}
+							var option971 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option971 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value970 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option971 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value970})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value965, result967, option969, option971})
+
+						case 31:
+							result993 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value972 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant981 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value973 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant981 = golem_core_types.MakeDiscriminatorRulePrefix(value973)
+
+								case 1:
+									value974 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant981 = golem_core_types.MakeDiscriminatorRuleSuffix(value974)
+
+								case 2:
+									value975 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant981 = golem_core_types.MakeDiscriminatorRuleContains(value975)
+
+								case 3:
+									value976 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant981 = golem_core_types.MakeDiscriminatorRuleRegex(value976)
+
+								case 4:
+									value977 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option979 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option979 = witTypes.None[string]()
+									case 1:
+										value978 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option979 = witTypes.Some[string](value978)
+									default:
+										panic("unreachable")
+									}
+
+									variant981 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value977, option979})
+
+								case 5:
+									value980 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant981 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value980)
+
+								default:
+									panic("unreachable")
+								}
+								var option983 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option983 = witTypes.None[string]()
+								case 1:
+									value982 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option983 = witTypes.Some[string](value982)
+								default:
+									panic("unreachable")
+								}
+								result985 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value984 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result985 = append(result985, value984)
+								}
+
+								result987 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value986 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result987 = append(result987, value986)
+								}
+
+								var option989 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option989 = witTypes.None[string]()
+								case 1:
+									value988 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option989 = witTypes.Some[string](value988)
+								default:
+									panic("unreachable")
+								}
+								var option992 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option992 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant991 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant991 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant991 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant991 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value990 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant991 = golem_core_types.MakeRoleOther(value990)
+
+									default:
+										panic("unreachable")
+									}
+
+									option992 = witTypes.Some[golem_core_types.Role](variant991)
+								default:
+									panic("unreachable")
+								}
+
+								result993 = append(result993, golem_core_types.UnionBranch{value972, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant981, golem_core_types.MetadataEnvelope{option983, result985, result987, option989, option992}})
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result993})
+
+						case 32:
+							var option995 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option995 = witTypes.None[string]()
+							case 1:
+								value994 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option995 = witTypes.Some[string](value994)
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option995})
+
+						case 33:
+							var option997 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option997 = witTypes.None[string]()
+							case 1:
+								value996 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option997 = witTypes.Some[string](value996)
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option997})
+
+						case 34:
+							var option998 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option998 = witTypes.None[int32]()
+							case 1:
+
+								option998 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyFutureType(option998)
+
+						case 35:
+							var option999 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option999 = witTypes.None[int32]()
+							case 1:
+
+								option999 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyStreamType(option999)
+
+						default:
+							panic("unreachable")
+						}
+						var option1002 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option1002 = witTypes.None[string]()
+						case 1:
+							value1001 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option1002 = witTypes.Some[string](value1001)
+						default:
+							panic("unreachable")
+						}
+						result1004 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value1003 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1004 = append(result1004, value1003)
+						}
+
+						result1006 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value1005 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1006 = append(result1006, value1005)
+						}
+
+						var option1008 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option1008 = witTypes.None[string]()
+						case 1:
+							value1007 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option1008 = witTypes.Some[string](value1007)
+						default:
+							panic("unreachable")
+						}
+						var option1011 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option1011 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant1010 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant1010 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant1010 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant1010 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value1009 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant1010 = golem_core_types.MakeRoleOther(value1009)
+
+							default:
+								panic("unreachable")
+							}
+
+							option1011 = witTypes.Some[golem_core_types.Role](variant1010)
+						default:
+							panic("unreachable")
+						}
+
+						result1012 = append(result1012, golem_core_types.SchemaTypeNode{variant1000, golem_core_types.MetadataEnvelope{option1002, result1004, result1006, option1008, option1011}})
+					}
+
+					result1016 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))), index*(6*4))
+						value1013 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option1015 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option1015 = witTypes.None[string]()
+						case 1:
+							value1014 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option1015 = witTypes.Some[string](value1014)
+						default:
+							panic("unreachable")
+						}
+
+						result1016 = append(result1016, golem_core_types.SchemaTypeDef{value1013, option1015, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result1040 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))), index*(16+4*4))
+						var variant1039 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value1017 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeStringValue(value1017)
+
+						case 13:
+							result1018 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1018 = append(result1018, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeRecordValue(result1018)
+
+						case 14:
+							var option1019 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option1019 = witTypes.None[int32]()
+							case 1:
+
+								option1019 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1019})
+
+						case 15:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result1020 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result1020 = append(result1020, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1020)
+
+						case 17:
+							result1021 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1021 = append(result1021, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeTupleValue(result1021)
+
+						case 18:
+							result1022 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1022 = append(result1022, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeListValue(result1022)
+
+						case 19:
+							result1023 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1023 = append(result1023, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1023)
+
+						case 20:
+							result1024 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result1024 = append(result1024, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeMapValue(result1024)
+
+						case 21:
+							var option1025 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1025 = witTypes.None[int32]()
+							case 1:
+
+								option1025 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeOptionValue(option1025)
+
+						case 22:
+							var variant1028 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option1026 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1026 = witTypes.None[int32]()
+								case 1:
+
+									option1026 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1028 = golem_core_types.MakeResultValuePayloadOkValue(option1026)
+
+							case 1:
+								var option1027 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1027 = witTypes.None[int32]()
+								case 1:
+
+									option1027 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1028 = golem_core_types.MakeResultValuePayloadErrValue(option1027)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeResultValue(variant1028)
+
+						case 23:
+							value1029 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1031 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1031 = witTypes.None[string]()
+							case 1:
+								value1030 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1031 = witTypes.Some[string](value1030)
+							default:
+								panic("unreachable")
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1029, option1031})
+
+						case 24:
+							value1032 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1034 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1034 = witTypes.None[string]()
+							case 1:
+								value1033 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1034 = witTypes.Some[string](value1033)
+							default:
+								panic("unreachable")
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1032, option1034})
+
+						case 25:
+							value1035 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1039 = golem_core_types.MakeSchemaValueNodePathValue(value1035)
+
+						case 26:
+							value1036 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeUrlValue(value1036)
+
+						case 27:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value1037 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1037})
+
+						case 30:
+							value1038 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1038, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result1040 = append(result1040, variant1039)
+					}
+
+					value1041 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4))))
+					result1043 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))))), index*(2*4))
+						value1042 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result1043 = append(result1043, value1042)
+					}
+
+					result1055 := make([][]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 14*4))))), index*(2*4))
+						result1054 := make([]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*(56+6*4))
+							var variant1053 SpanData
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value1044 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var option1046 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) {
+								case 0:
+
+									option1046 = witTypes.None[string]()
+								case 1:
+									value1045 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+									option1046 = witTypes.Some[string](value1045)
+								default:
+									panic("unreachable")
+								}
+								var option1047 witTypes.Option[uint64]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) {
+								case 0:
+
+									option1047 = witTypes.None[uint64]()
+								case 1:
+
+									option1047 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))))
+								default:
+									panic("unreachable")
+								}
+								result1051 := make([]golem_api_context.Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))), index*(5*4))
+									value1048 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+									var variant1050 golem_api_context.AttributeValue
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+									case 0:
+										value1049 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+										variant1050 = golem_api_context.MakeAttributeValueString(value1049)
+
+									default:
+										panic("unreachable")
+									}
+
+									result1051 = append(result1051, golem_api_context.Attribute{value1048, variant1050})
+								}
+
+								variant1053 = MakeSpanDataLocalSpan(LocalSpanData{value1044, wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))}, option1046, option1047, result1051, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)})
+
+							case 1:
+								value1052 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant1053 = MakeSpanDataExternalSpan(ExternalSpanData{value1052})
+
+							default:
+								panic("unreachable")
+							}
+
+							result1054 = append(result1054, variant1053)
+						}
+
+						result1055 = append(result1055, result1054)
+					}
+
+					variant1280 = MakeAgentInvocationAgentInitialization(AgentInitializationParameters{value836, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1012, result1016, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))}, golem_core_types.SchemaValueTree{result1040, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4)))}}, value1041, result1043, result1055})
+
+				case 1:
+					value1056 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+					value1057 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+					result1233 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))), index*(56+22*4))
+						var variant1221 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option1064 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1064 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1059 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1059 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1058 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1058 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1058 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1058 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1059 = witTypes.Some[golem_core_types.NumericBound](variant1058)
+								default:
+									panic("unreachable")
+								}
+								var option1061 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1061 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1060 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1060 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1060 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1060 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1061 = witTypes.Some[golem_core_types.NumericBound](variant1060)
+								default:
+									panic("unreachable")
+								}
+								var option1063 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1063 = witTypes.None[string]()
+								case 1:
+									value1062 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1063 = witTypes.Some[string](value1062)
+								default:
+									panic("unreachable")
+								}
+
+								option1064 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1059, option1061, option1063})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyS8Type(option1064)
+
+						case 3:
+							var option1071 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1071 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1066 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1066 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1065 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1065 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1065 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1065 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1066 = witTypes.Some[golem_core_types.NumericBound](variant1065)
+								default:
+									panic("unreachable")
+								}
+								var option1068 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1068 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1067 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1067 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1067 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1067 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1068 = witTypes.Some[golem_core_types.NumericBound](variant1067)
+								default:
+									panic("unreachable")
+								}
+								var option1070 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1070 = witTypes.None[string]()
+								case 1:
+									value1069 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1070 = witTypes.Some[string](value1069)
+								default:
+									panic("unreachable")
+								}
+
+								option1071 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1066, option1068, option1070})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyS16Type(option1071)
+
+						case 4:
+							var option1078 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1078 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1073 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1073 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1072 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1072 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1072 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1072 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1073 = witTypes.Some[golem_core_types.NumericBound](variant1072)
+								default:
+									panic("unreachable")
+								}
+								var option1075 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1075 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1074 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1074 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1074 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1074 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1075 = witTypes.Some[golem_core_types.NumericBound](variant1074)
+								default:
+									panic("unreachable")
+								}
+								var option1077 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1077 = witTypes.None[string]()
+								case 1:
+									value1076 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1077 = witTypes.Some[string](value1076)
+								default:
+									panic("unreachable")
+								}
+
+								option1078 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1073, option1075, option1077})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyS32Type(option1078)
+
+						case 5:
+							var option1085 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1085 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1080 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1080 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1079 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1079 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1079 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1079 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1080 = witTypes.Some[golem_core_types.NumericBound](variant1079)
+								default:
+									panic("unreachable")
+								}
+								var option1082 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1082 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1081 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1081 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1081 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1081 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1082 = witTypes.Some[golem_core_types.NumericBound](variant1081)
+								default:
+									panic("unreachable")
+								}
+								var option1084 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1084 = witTypes.None[string]()
+								case 1:
+									value1083 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1084 = witTypes.Some[string](value1083)
+								default:
+									panic("unreachable")
+								}
+
+								option1085 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1080, option1082, option1084})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyS64Type(option1085)
+
+						case 6:
+							var option1092 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1092 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1087 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1087 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1086 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1086 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1086 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1086 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1087 = witTypes.Some[golem_core_types.NumericBound](variant1086)
+								default:
+									panic("unreachable")
+								}
+								var option1089 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1089 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1088 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1088 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1088 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1088 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1089 = witTypes.Some[golem_core_types.NumericBound](variant1088)
+								default:
+									panic("unreachable")
+								}
+								var option1091 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1091 = witTypes.None[string]()
+								case 1:
+									value1090 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1091 = witTypes.Some[string](value1090)
+								default:
+									panic("unreachable")
+								}
+
+								option1092 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1087, option1089, option1091})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyU8Type(option1092)
+
+						case 7:
+							var option1099 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1099 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1094 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1094 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1093 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1093 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1093 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1093 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1094 = witTypes.Some[golem_core_types.NumericBound](variant1093)
+								default:
+									panic("unreachable")
+								}
+								var option1096 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1096 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1095 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1095 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1095 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1095 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1096 = witTypes.Some[golem_core_types.NumericBound](variant1095)
+								default:
+									panic("unreachable")
+								}
+								var option1098 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1098 = witTypes.None[string]()
+								case 1:
+									value1097 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1098 = witTypes.Some[string](value1097)
+								default:
+									panic("unreachable")
+								}
+
+								option1099 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1094, option1096, option1098})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyU16Type(option1099)
+
+						case 8:
+							var option1106 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1106 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1101 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1101 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1100 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1100 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1100 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1100 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1101 = witTypes.Some[golem_core_types.NumericBound](variant1100)
+								default:
+									panic("unreachable")
+								}
+								var option1103 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1103 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1102 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1102 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1102 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1102 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1103 = witTypes.Some[golem_core_types.NumericBound](variant1102)
+								default:
+									panic("unreachable")
+								}
+								var option1105 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1105 = witTypes.None[string]()
+								case 1:
+									value1104 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1105 = witTypes.Some[string](value1104)
+								default:
+									panic("unreachable")
+								}
+
+								option1106 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1101, option1103, option1105})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyU32Type(option1106)
+
+						case 9:
+							var option1113 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1113 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1108 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1108 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1107 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1107 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1107 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1107 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1108 = witTypes.Some[golem_core_types.NumericBound](variant1107)
+								default:
+									panic("unreachable")
+								}
+								var option1110 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1110 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1109 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1109 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1109 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1109 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1110 = witTypes.Some[golem_core_types.NumericBound](variant1109)
+								default:
+									panic("unreachable")
+								}
+								var option1112 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1112 = witTypes.None[string]()
+								case 1:
+									value1111 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1112 = witTypes.Some[string](value1111)
+								default:
+									panic("unreachable")
+								}
+
+								option1113 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1108, option1110, option1112})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyU64Type(option1113)
+
+						case 10:
+							var option1120 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1120 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1115 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1115 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1114 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1114 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1114 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1114 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1115 = witTypes.Some[golem_core_types.NumericBound](variant1114)
+								default:
+									panic("unreachable")
+								}
+								var option1117 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1117 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1116 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1116 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1116 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1116 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1117 = witTypes.Some[golem_core_types.NumericBound](variant1116)
+								default:
+									panic("unreachable")
+								}
+								var option1119 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1119 = witTypes.None[string]()
+								case 1:
+									value1118 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1119 = witTypes.Some[string](value1118)
+								default:
+									panic("unreachable")
+								}
+
+								option1120 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1115, option1117, option1119})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyF32Type(option1120)
+
+						case 11:
+							var option1127 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1127 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1122 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1122 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1121 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1121 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1121 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1121 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1122 = witTypes.Some[golem_core_types.NumericBound](variant1121)
+								default:
+									panic("unreachable")
+								}
+								var option1124 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1124 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1123 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1123 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1123 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1123 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1124 = witTypes.Some[golem_core_types.NumericBound](variant1123)
+								default:
+									panic("unreachable")
+								}
+								var option1126 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1126 = witTypes.None[string]()
+								case 1:
+									value1125 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1126 = witTypes.Some[string](value1125)
+								default:
+									panic("unreachable")
+								}
+
+								option1127 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1122, option1124, option1126})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyF64Type(option1127)
+
+						case 12:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result1140 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value1128 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1130 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option1130 = witTypes.None[string]()
+								case 1:
+									value1129 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option1130 = witTypes.Some[string](value1129)
+								default:
+									panic("unreachable")
+								}
+								result1132 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value1131 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1132 = append(result1132, value1131)
+								}
+
+								result1134 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value1133 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1134 = append(result1134, value1133)
+								}
+
+								var option1136 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option1136 = witTypes.None[string]()
+								case 1:
+									value1135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option1136 = witTypes.Some[string](value1135)
+								default:
+									panic("unreachable")
+								}
+								var option1139 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option1139 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1138 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant1138 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1138 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1138 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1137 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant1138 = golem_core_types.MakeRoleOther(value1137)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1139 = witTypes.Some[golem_core_types.Role](variant1138)
+								default:
+									panic("unreachable")
+								}
+
+								result1140 = append(result1140, golem_core_types.NamedFieldType{value1128, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1130, result1132, result1134, option1136, option1139}})
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyRecordType(result1140)
+
+						case 15:
+							result1154 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value1141 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1142 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option1142 = witTypes.None[int32]()
+								case 1:
+
+									option1142 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option1144 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option1144 = witTypes.None[string]()
+								case 1:
+									value1143 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option1144 = witTypes.Some[string](value1143)
+								default:
+									panic("unreachable")
+								}
+								result1146 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1145 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1146 = append(result1146, value1145)
+								}
+
+								result1148 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value1147 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1148 = append(result1148, value1147)
+								}
+
+								var option1150 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option1150 = witTypes.None[string]()
+								case 1:
+									value1149 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option1150 = witTypes.Some[string](value1149)
+								default:
+									panic("unreachable")
+								}
+								var option1153 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option1153 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1152 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant1152 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1152 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1152 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1151 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant1152 = golem_core_types.MakeRoleOther(value1151)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1153 = witTypes.Some[golem_core_types.Role](variant1152)
+								default:
+									panic("unreachable")
+								}
+
+								result1154 = append(result1154, golem_core_types.VariantCaseType{value1141, option1142, golem_core_types.MetadataEnvelope{option1144, result1146, result1148, option1150, option1153}})
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyVariantType(result1154)
+
+						case 16:
+							result1156 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1155 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1156 = append(result1156, value1155)
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyEnumType(result1156)
+
+						case 17:
+							result1158 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1157 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1158 = append(result1158, value1157)
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1158)
+
+						case 18:
+							result1159 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1159 = append(result1159, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyTupleType(result1159)
+
+						case 19:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option1160 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1160 = witTypes.None[int32]()
+							case 1:
+
+								option1160 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option1161 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option1161 = witTypes.None[int32]()
+							case 1:
+
+								option1161 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1160, option1161})
+
+						case 24:
+							var option1164 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1164 = witTypes.None[[]string]()
+							case 1:
+								result1163 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1162 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1163 = append(result1163, value1162)
+								}
+
+								option1164 = witTypes.Some[[]string](result1163)
+							default:
+								panic("unreachable")
+							}
+							var option1165 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1165 = witTypes.None[uint32]()
+							case 1:
+
+								option1165 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1166 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1166 = witTypes.None[uint32]()
+							case 1:
+
+								option1166 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1168 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option1168 = witTypes.None[string]()
+							case 1:
+								value1167 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option1168 = witTypes.Some[string](value1167)
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1164, option1165, option1166, option1168})
+
+						case 25:
+							var option1171 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1171 = witTypes.None[[]string]()
+							case 1:
+								result1170 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1170 = append(result1170, value1169)
+								}
+
+								option1171 = witTypes.Some[[]string](result1170)
+							default:
+								panic("unreachable")
+							}
+							var option1172 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1172 = witTypes.None[uint32]()
+							case 1:
+
+								option1172 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1173 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1173 = witTypes.None[uint32]()
+							case 1:
+
+								option1173 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1171, option1172, option1173})
+
+						case 26:
+							var option1176 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1176 = witTypes.None[[]string]()
+							case 1:
+								result1175 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value1174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1175 = append(result1175, value1174)
+								}
+
+								option1176 = witTypes.Some[[]string](result1175)
+							default:
+								panic("unreachable")
+							}
+							var option1179 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1179 = witTypes.None[[]string]()
+							case 1:
+								result1178 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1177 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1178 = append(result1178, value1177)
+								}
+
+								option1179 = witTypes.Some[[]string](result1178)
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option1176, option1179})
+
+						case 27:
+							var option1182 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1182 = witTypes.None[[]string]()
+							case 1:
+								result1181 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1180 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1181 = append(result1181, value1180)
+								}
+
+								option1182 = witTypes.Some[[]string](result1181)
+							default:
+								panic("unreachable")
+							}
+							var option1185 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1185 = witTypes.None[[]string]()
+							case 1:
+								result1184 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value1183 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1184 = append(result1184, value1183)
+								}
+
+								option1185 = witTypes.Some[[]string](result1184)
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1182, option1185})
+
+						case 28:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value1186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result1188 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value1187 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1188 = append(result1188, value1187)
+							}
+
+							var option1190 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1190 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1189 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option1190 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value1189})
+							default:
+								panic("unreachable")
+							}
+							var option1192 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option1192 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1191 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option1192 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value1191})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1186, result1188, option1190, option1192})
+
+						case 31:
+							result1214 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value1193 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant1202 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value1194 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1202 = golem_core_types.MakeDiscriminatorRulePrefix(value1194)
+
+								case 1:
+									value1195 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1202 = golem_core_types.MakeDiscriminatorRuleSuffix(value1195)
+
+								case 2:
+									value1196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1202 = golem_core_types.MakeDiscriminatorRuleContains(value1196)
+
+								case 3:
+									value1197 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1202 = golem_core_types.MakeDiscriminatorRuleRegex(value1197)
+
+								case 4:
+									value1198 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option1200 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option1200 = witTypes.None[string]()
+									case 1:
+										value1199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option1200 = witTypes.Some[string](value1199)
+									default:
+										panic("unreachable")
+									}
+
+									variant1202 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1198, option1200})
+
+								case 5:
+									value1201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1202 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1201)
+
+								default:
+									panic("unreachable")
+								}
+								var option1204 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option1204 = witTypes.None[string]()
+								case 1:
+									value1203 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option1204 = witTypes.Some[string](value1203)
+								default:
+									panic("unreachable")
+								}
+								result1206 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value1205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1206 = append(result1206, value1205)
+								}
+
+								result1208 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value1207 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1208 = append(result1208, value1207)
+								}
+
+								var option1210 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option1210 = witTypes.None[string]()
+								case 1:
+									value1209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option1210 = witTypes.Some[string](value1209)
+								default:
+									panic("unreachable")
+								}
+								var option1213 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option1213 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1212 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant1212 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1212 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1212 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1211 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant1212 = golem_core_types.MakeRoleOther(value1211)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1213 = witTypes.Some[golem_core_types.Role](variant1212)
+								default:
+									panic("unreachable")
+								}
+
+								result1214 = append(result1214, golem_core_types.UnionBranch{value1193, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1202, golem_core_types.MetadataEnvelope{option1204, result1206, result1208, option1210, option1213}})
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1214})
+
+						case 32:
+							var option1216 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1216 = witTypes.None[string]()
+							case 1:
+								value1215 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option1216 = witTypes.Some[string](value1215)
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1216})
+
+						case 33:
+							var option1218 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1218 = witTypes.None[string]()
+							case 1:
+								value1217 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option1218 = witTypes.Some[string](value1217)
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1218})
+
+						case 34:
+							var option1219 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1219 = witTypes.None[int32]()
+							case 1:
+
+								option1219 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyFutureType(option1219)
+
+						case 35:
+							var option1220 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1220 = witTypes.None[int32]()
+							case 1:
+
+								option1220 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyStreamType(option1220)
+
+						default:
+							panic("unreachable")
+						}
+						var option1223 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option1223 = witTypes.None[string]()
+						case 1:
+							value1222 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option1223 = witTypes.Some[string](value1222)
+						default:
+							panic("unreachable")
+						}
+						result1225 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value1224 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1225 = append(result1225, value1224)
+						}
+
+						result1227 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value1226 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1227 = append(result1227, value1226)
+						}
+
+						var option1229 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option1229 = witTypes.None[string]()
+						case 1:
+							value1228 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option1229 = witTypes.Some[string](value1228)
+						default:
+							panic("unreachable")
+						}
+						var option1232 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option1232 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant1231 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant1231 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant1231 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant1231 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value1230 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant1231 = golem_core_types.MakeRoleOther(value1230)
+
+							default:
+								panic("unreachable")
+							}
+
+							option1232 = witTypes.Some[golem_core_types.Role](variant1231)
+						default:
+							panic("unreachable")
+						}
+
+						result1233 = append(result1233, golem_core_types.SchemaTypeNode{variant1221, golem_core_types.MetadataEnvelope{option1223, result1225, result1227, option1229, option1232}})
+					}
+
+					result1237 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))))), index*(6*4))
+						value1234 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option1236 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option1236 = witTypes.None[string]()
+						case 1:
+							value1235 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option1236 = witTypes.Some[string](value1235)
+						default:
+							panic("unreachable")
+						}
+
+						result1237 = append(result1237, golem_core_types.SchemaTypeDef{value1234, option1236, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result1261 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4))))), index*(16+4*4))
+						var variant1260 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value1238 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeStringValue(value1238)
+
+						case 13:
+							result1239 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1239 = append(result1239, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeRecordValue(result1239)
+
+						case 14:
+							var option1240 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option1240 = witTypes.None[int32]()
+							case 1:
+
+								option1240 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1240})
+
+						case 15:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result1241 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result1241 = append(result1241, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1241)
+
+						case 17:
+							result1242 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1242 = append(result1242, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeTupleValue(result1242)
+
+						case 18:
+							result1243 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1243 = append(result1243, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeListValue(result1243)
+
+						case 19:
+							result1244 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1244 = append(result1244, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1244)
+
+						case 20:
+							result1245 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result1245 = append(result1245, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeMapValue(result1245)
+
+						case 21:
+							var option1246 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1246 = witTypes.None[int32]()
+							case 1:
+
+								option1246 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeOptionValue(option1246)
+
+						case 22:
+							var variant1249 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option1247 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1247 = witTypes.None[int32]()
+								case 1:
+
+									option1247 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1249 = golem_core_types.MakeResultValuePayloadOkValue(option1247)
+
+							case 1:
+								var option1248 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1248 = witTypes.None[int32]()
+								case 1:
+
+									option1248 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1249 = golem_core_types.MakeResultValuePayloadErrValue(option1248)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeResultValue(variant1249)
+
+						case 23:
+							value1250 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1252 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1252 = witTypes.None[string]()
+							case 1:
+								value1251 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1252 = witTypes.Some[string](value1251)
+							default:
+								panic("unreachable")
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1250, option1252})
+
+						case 24:
+							value1253 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1255 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1255 = witTypes.None[string]()
+							case 1:
+								value1254 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1255 = witTypes.Some[string](value1254)
+							default:
+								panic("unreachable")
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1253, option1255})
+
+						case 25:
+							value1256 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1260 = golem_core_types.MakeSchemaValueNodePathValue(value1256)
+
+						case 26:
+							value1257 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeUrlValue(value1257)
+
+						case 27:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value1258 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1258})
+
+						case 30:
+							value1259 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1259, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result1261 = append(result1261, variant1260)
+					}
+
+					value1262 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4))))
+					result1264 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 14*4))))), index*(2*4))
+						value1263 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result1264 = append(result1264, value1263)
+					}
+
+					result1276 := make([][]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 17*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 17*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 16*4))))), index*(2*4))
+						result1275 := make([]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*(56+6*4))
+							var variant1274 SpanData
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value1265 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var option1267 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) {
+								case 0:
+
+									option1267 = witTypes.None[string]()
+								case 1:
+									value1266 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+									option1267 = witTypes.Some[string](value1266)
+								default:
+									panic("unreachable")
+								}
+								var option1268 witTypes.Option[uint64]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) {
+								case 0:
+
+									option1268 = witTypes.None[uint64]()
+								case 1:
+
+									option1268 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))))
+								default:
+									panic("unreachable")
+								}
+								result1272 := make([]golem_api_context.Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))), index*(5*4))
+									value1269 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+									var variant1271 golem_api_context.AttributeValue
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+									case 0:
+										value1270 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+										variant1271 = golem_api_context.MakeAttributeValueString(value1270)
+
+									default:
+										panic("unreachable")
+									}
+
+									result1272 = append(result1272, golem_api_context.Attribute{value1269, variant1271})
+								}
+
+								variant1274 = MakeSpanDataLocalSpan(LocalSpanData{value1265, wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))}, option1267, option1268, result1272, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)})
+
+							case 1:
+								value1273 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant1274 = MakeSpanDataExternalSpan(ExternalSpanData{value1273})
+
+							default:
+								panic("unreachable")
+							}
+
+							result1275 = append(result1275, variant1274)
+						}
+
+						result1276 = append(result1276, result1275)
+					}
+
+					variant1280 = MakeAgentInvocationAgentMethodInvocation(AgentMethodInvocationParameters{value1056, value1057, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1233, result1237, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}, golem_core_types.SchemaValueTree{result1261, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4)))}}, value1262, result1264, result1276})
+
+				case 2:
+
+					variant1280 = MakeAgentInvocationSaveSnapshot()
+
+				case 3:
+					value1277 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+					value1278 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+
+					variant1280 = MakeAgentInvocationLoadSnapshot(LoadSnapshotParameters{SnapshotData{value1277, value1278}})
+
+				case 4:
+					value1279 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+
+					variant1280 = MakeAgentInvocationProcessOplogEntries(ProcessOplogEntriesParameters{value1279})
+
+				case 5:
+
+					variant1280 = MakeAgentInvocationManualUpdate(ManualUpdateParameters{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))})
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryAgentInvocationStarted(AgentInvocationStartedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, variant1280})
+
+			case 5:
+				var variant1695 AgentInvocationResult
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+				case 0:
+					result1456 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))), index*(56+22*4))
+						var variant1444 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option1287 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1287 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1282 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1282 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1281 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1281 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1281 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1281 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1282 = witTypes.Some[golem_core_types.NumericBound](variant1281)
+								default:
+									panic("unreachable")
+								}
+								var option1284 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1284 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1283 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1283 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1283 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1283 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1284 = witTypes.Some[golem_core_types.NumericBound](variant1283)
+								default:
+									panic("unreachable")
+								}
+								var option1286 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1286 = witTypes.None[string]()
+								case 1:
+									value1285 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1286 = witTypes.Some[string](value1285)
+								default:
+									panic("unreachable")
+								}
+
+								option1287 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1282, option1284, option1286})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyS8Type(option1287)
+
+						case 3:
+							var option1294 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1294 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1289 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1289 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1288 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1288 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1288 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1288 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1289 = witTypes.Some[golem_core_types.NumericBound](variant1288)
+								default:
+									panic("unreachable")
+								}
+								var option1291 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1291 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1290 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1290 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1290 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1290 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1291 = witTypes.Some[golem_core_types.NumericBound](variant1290)
+								default:
+									panic("unreachable")
+								}
+								var option1293 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1293 = witTypes.None[string]()
+								case 1:
+									value1292 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1293 = witTypes.Some[string](value1292)
+								default:
+									panic("unreachable")
+								}
+
+								option1294 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1289, option1291, option1293})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyS16Type(option1294)
+
+						case 4:
+							var option1301 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1301 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1296 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1296 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1295 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1295 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1295 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1295 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1296 = witTypes.Some[golem_core_types.NumericBound](variant1295)
+								default:
+									panic("unreachable")
+								}
+								var option1298 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1298 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1297 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1297 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1297 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1297 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1298 = witTypes.Some[golem_core_types.NumericBound](variant1297)
+								default:
+									panic("unreachable")
+								}
+								var option1300 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1300 = witTypes.None[string]()
+								case 1:
+									value1299 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1300 = witTypes.Some[string](value1299)
+								default:
+									panic("unreachable")
+								}
+
+								option1301 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1296, option1298, option1300})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyS32Type(option1301)
+
+						case 5:
+							var option1308 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1308 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1303 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1303 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1302 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1302 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1302 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1302 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1303 = witTypes.Some[golem_core_types.NumericBound](variant1302)
+								default:
+									panic("unreachable")
+								}
+								var option1305 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1305 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1304 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1304 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1304 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1304 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1305 = witTypes.Some[golem_core_types.NumericBound](variant1304)
+								default:
+									panic("unreachable")
+								}
+								var option1307 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1307 = witTypes.None[string]()
+								case 1:
+									value1306 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1307 = witTypes.Some[string](value1306)
+								default:
+									panic("unreachable")
+								}
+
+								option1308 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1303, option1305, option1307})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyS64Type(option1308)
+
+						case 6:
+							var option1315 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1315 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1310 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1310 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1309 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1309 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1309 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1309 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1310 = witTypes.Some[golem_core_types.NumericBound](variant1309)
+								default:
+									panic("unreachable")
+								}
+								var option1312 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1312 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1311 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1311 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1311 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1311 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1312 = witTypes.Some[golem_core_types.NumericBound](variant1311)
+								default:
+									panic("unreachable")
+								}
+								var option1314 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1314 = witTypes.None[string]()
+								case 1:
+									value1313 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1314 = witTypes.Some[string](value1313)
+								default:
+									panic("unreachable")
+								}
+
+								option1315 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1310, option1312, option1314})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyU8Type(option1315)
+
+						case 7:
+							var option1322 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1322 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1317 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1317 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1316 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1316 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1316 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1316 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1317 = witTypes.Some[golem_core_types.NumericBound](variant1316)
+								default:
+									panic("unreachable")
+								}
+								var option1319 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1319 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1318 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1318 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1318 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1318 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1319 = witTypes.Some[golem_core_types.NumericBound](variant1318)
+								default:
+									panic("unreachable")
+								}
+								var option1321 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1321 = witTypes.None[string]()
+								case 1:
+									value1320 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1321 = witTypes.Some[string](value1320)
+								default:
+									panic("unreachable")
+								}
+
+								option1322 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1317, option1319, option1321})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyU16Type(option1322)
+
+						case 8:
+							var option1329 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1329 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1324 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1324 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1323 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1323 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1323 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1323 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1324 = witTypes.Some[golem_core_types.NumericBound](variant1323)
+								default:
+									panic("unreachable")
+								}
+								var option1326 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1326 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1325 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1325 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1325 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1325 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1326 = witTypes.Some[golem_core_types.NumericBound](variant1325)
+								default:
+									panic("unreachable")
+								}
+								var option1328 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1328 = witTypes.None[string]()
+								case 1:
+									value1327 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1328 = witTypes.Some[string](value1327)
+								default:
+									panic("unreachable")
+								}
+
+								option1329 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1324, option1326, option1328})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyU32Type(option1329)
+
+						case 9:
+							var option1336 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1336 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1331 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1331 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1330 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1330 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1330 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1330 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1331 = witTypes.Some[golem_core_types.NumericBound](variant1330)
+								default:
+									panic("unreachable")
+								}
+								var option1333 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1333 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1332 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1332 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1332 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1332 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1333 = witTypes.Some[golem_core_types.NumericBound](variant1332)
+								default:
+									panic("unreachable")
+								}
+								var option1335 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1335 = witTypes.None[string]()
+								case 1:
+									value1334 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1335 = witTypes.Some[string](value1334)
+								default:
+									panic("unreachable")
+								}
+
+								option1336 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1331, option1333, option1335})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyU64Type(option1336)
+
+						case 10:
+							var option1343 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1343 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1338 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1338 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1337 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1337 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1337 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1337 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1338 = witTypes.Some[golem_core_types.NumericBound](variant1337)
+								default:
+									panic("unreachable")
+								}
+								var option1340 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1340 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1339 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1339 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1339 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1339 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1340 = witTypes.Some[golem_core_types.NumericBound](variant1339)
+								default:
+									panic("unreachable")
+								}
+								var option1342 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1342 = witTypes.None[string]()
+								case 1:
+									value1341 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1342 = witTypes.Some[string](value1341)
+								default:
+									panic("unreachable")
+								}
+
+								option1343 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1338, option1340, option1342})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyF32Type(option1343)
+
+						case 11:
+							var option1350 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1350 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1345 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1345 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1344 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1344 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1344 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1344 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1345 = witTypes.Some[golem_core_types.NumericBound](variant1344)
+								default:
+									panic("unreachable")
+								}
+								var option1347 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1347 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1346 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1346 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1346 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1346 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1347 = witTypes.Some[golem_core_types.NumericBound](variant1346)
+								default:
+									panic("unreachable")
+								}
+								var option1349 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1349 = witTypes.None[string]()
+								case 1:
+									value1348 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1349 = witTypes.Some[string](value1348)
+								default:
+									panic("unreachable")
+								}
+
+								option1350 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1345, option1347, option1349})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyF64Type(option1350)
+
+						case 12:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result1363 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value1351 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1353 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option1353 = witTypes.None[string]()
+								case 1:
+									value1352 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option1353 = witTypes.Some[string](value1352)
+								default:
+									panic("unreachable")
+								}
+								result1355 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value1354 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1355 = append(result1355, value1354)
+								}
+
+								result1357 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value1356 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1357 = append(result1357, value1356)
+								}
+
+								var option1359 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option1359 = witTypes.None[string]()
+								case 1:
+									value1358 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option1359 = witTypes.Some[string](value1358)
+								default:
+									panic("unreachable")
+								}
+								var option1362 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option1362 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1361 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant1361 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1361 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1361 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1360 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant1361 = golem_core_types.MakeRoleOther(value1360)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1362 = witTypes.Some[golem_core_types.Role](variant1361)
+								default:
+									panic("unreachable")
+								}
+
+								result1363 = append(result1363, golem_core_types.NamedFieldType{value1351, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1353, result1355, result1357, option1359, option1362}})
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyRecordType(result1363)
+
+						case 15:
+							result1377 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value1364 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1365 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option1365 = witTypes.None[int32]()
+								case 1:
+
+									option1365 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option1367 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option1367 = witTypes.None[string]()
+								case 1:
+									value1366 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option1367 = witTypes.Some[string](value1366)
+								default:
+									panic("unreachable")
+								}
+								result1369 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1368 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1369 = append(result1369, value1368)
+								}
+
+								result1371 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value1370 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1371 = append(result1371, value1370)
+								}
+
+								var option1373 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option1373 = witTypes.None[string]()
+								case 1:
+									value1372 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option1373 = witTypes.Some[string](value1372)
+								default:
+									panic("unreachable")
+								}
+								var option1376 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option1376 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1375 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant1375 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1375 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1375 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1374 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant1375 = golem_core_types.MakeRoleOther(value1374)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1376 = witTypes.Some[golem_core_types.Role](variant1375)
+								default:
+									panic("unreachable")
+								}
+
+								result1377 = append(result1377, golem_core_types.VariantCaseType{value1364, option1365, golem_core_types.MetadataEnvelope{option1367, result1369, result1371, option1373, option1376}})
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyVariantType(result1377)
+
+						case 16:
+							result1379 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1378 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1379 = append(result1379, value1378)
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyEnumType(result1379)
+
+						case 17:
+							result1381 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1380 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1381 = append(result1381, value1380)
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1381)
+
+						case 18:
+							result1382 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1382 = append(result1382, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyTupleType(result1382)
+
+						case 19:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option1383 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1383 = witTypes.None[int32]()
+							case 1:
+
+								option1383 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option1384 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option1384 = witTypes.None[int32]()
+							case 1:
+
+								option1384 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1383, option1384})
+
+						case 24:
+							var option1387 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1387 = witTypes.None[[]string]()
+							case 1:
+								result1386 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1385 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1386 = append(result1386, value1385)
+								}
+
+								option1387 = witTypes.Some[[]string](result1386)
+							default:
+								panic("unreachable")
+							}
+							var option1388 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1388 = witTypes.None[uint32]()
+							case 1:
+
+								option1388 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1389 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1389 = witTypes.None[uint32]()
+							case 1:
+
+								option1389 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1391 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option1391 = witTypes.None[string]()
+							case 1:
+								value1390 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option1391 = witTypes.Some[string](value1390)
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1387, option1388, option1389, option1391})
+
+						case 25:
+							var option1394 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1394 = witTypes.None[[]string]()
+							case 1:
+								result1393 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1392 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1393 = append(result1393, value1392)
+								}
+
+								option1394 = witTypes.Some[[]string](result1393)
+							default:
+								panic("unreachable")
+							}
+							var option1395 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1395 = witTypes.None[uint32]()
+							case 1:
+
+								option1395 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1396 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1396 = witTypes.None[uint32]()
+							case 1:
+
+								option1396 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1394, option1395, option1396})
+
+						case 26:
+							var option1399 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1399 = witTypes.None[[]string]()
+							case 1:
+								result1398 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value1397 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1398 = append(result1398, value1397)
+								}
+
+								option1399 = witTypes.Some[[]string](result1398)
+							default:
+								panic("unreachable")
+							}
+							var option1402 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1402 = witTypes.None[[]string]()
+							case 1:
+								result1401 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1400 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1401 = append(result1401, value1400)
+								}
+
+								option1402 = witTypes.Some[[]string](result1401)
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option1399, option1402})
+
+						case 27:
+							var option1405 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1405 = witTypes.None[[]string]()
+							case 1:
+								result1404 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1403 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1404 = append(result1404, value1403)
+								}
+
+								option1405 = witTypes.Some[[]string](result1404)
+							default:
+								panic("unreachable")
+							}
+							var option1408 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1408 = witTypes.None[[]string]()
+							case 1:
+								result1407 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value1406 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1407 = append(result1407, value1406)
+								}
+
+								option1408 = witTypes.Some[[]string](result1407)
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1405, option1408})
+
+						case 28:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value1409 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result1411 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value1410 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1411 = append(result1411, value1410)
+							}
+
+							var option1413 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1413 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1412 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option1413 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value1412})
+							default:
+								panic("unreachable")
+							}
+							var option1415 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option1415 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1414 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option1415 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value1414})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1409, result1411, option1413, option1415})
+
+						case 31:
+							result1437 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value1416 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant1425 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value1417 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1425 = golem_core_types.MakeDiscriminatorRulePrefix(value1417)
+
+								case 1:
+									value1418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1425 = golem_core_types.MakeDiscriminatorRuleSuffix(value1418)
+
+								case 2:
+									value1419 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1425 = golem_core_types.MakeDiscriminatorRuleContains(value1419)
+
+								case 3:
+									value1420 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1425 = golem_core_types.MakeDiscriminatorRuleRegex(value1420)
+
+								case 4:
+									value1421 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option1423 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option1423 = witTypes.None[string]()
+									case 1:
+										value1422 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option1423 = witTypes.Some[string](value1422)
+									default:
+										panic("unreachable")
+									}
+
+									variant1425 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1421, option1423})
+
+								case 5:
+									value1424 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1425 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1424)
+
+								default:
+									panic("unreachable")
+								}
+								var option1427 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option1427 = witTypes.None[string]()
+								case 1:
+									value1426 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option1427 = witTypes.Some[string](value1426)
+								default:
+									panic("unreachable")
+								}
+								result1429 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value1428 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1429 = append(result1429, value1428)
+								}
+
+								result1431 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value1430 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1431 = append(result1431, value1430)
+								}
+
+								var option1433 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option1433 = witTypes.None[string]()
+								case 1:
+									value1432 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option1433 = witTypes.Some[string](value1432)
+								default:
+									panic("unreachable")
+								}
+								var option1436 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option1436 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1435 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant1435 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1435 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1435 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1434 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant1435 = golem_core_types.MakeRoleOther(value1434)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1436 = witTypes.Some[golem_core_types.Role](variant1435)
+								default:
+									panic("unreachable")
+								}
+
+								result1437 = append(result1437, golem_core_types.UnionBranch{value1416, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1425, golem_core_types.MetadataEnvelope{option1427, result1429, result1431, option1433, option1436}})
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1437})
+
+						case 32:
+							var option1439 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1439 = witTypes.None[string]()
+							case 1:
+								value1438 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option1439 = witTypes.Some[string](value1438)
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1439})
+
+						case 33:
+							var option1441 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1441 = witTypes.None[string]()
+							case 1:
+								value1440 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option1441 = witTypes.Some[string](value1440)
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1441})
+
+						case 34:
+							var option1442 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1442 = witTypes.None[int32]()
+							case 1:
+
+								option1442 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyFutureType(option1442)
+
+						case 35:
+							var option1443 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1443 = witTypes.None[int32]()
+							case 1:
+
+								option1443 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyStreamType(option1443)
+
+						default:
+							panic("unreachable")
+						}
+						var option1446 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option1446 = witTypes.None[string]()
+						case 1:
+							value1445 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option1446 = witTypes.Some[string](value1445)
+						default:
+							panic("unreachable")
+						}
+						result1448 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value1447 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1448 = append(result1448, value1447)
+						}
+
+						result1450 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value1449 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1450 = append(result1450, value1449)
+						}
+
+						var option1452 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option1452 = witTypes.None[string]()
+						case 1:
+							value1451 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option1452 = witTypes.Some[string](value1451)
+						default:
+							panic("unreachable")
+						}
+						var option1455 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option1455 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant1454 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant1454 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant1454 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant1454 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value1453 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant1454 = golem_core_types.MakeRoleOther(value1453)
+
+							default:
+								panic("unreachable")
+							}
+
+							option1455 = witTypes.Some[golem_core_types.Role](variant1454)
+						default:
+							panic("unreachable")
+						}
+
+						result1456 = append(result1456, golem_core_types.SchemaTypeNode{variant1444, golem_core_types.MetadataEnvelope{option1446, result1448, result1450, option1452, option1455}})
+					}
+
+					result1460 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))))), index*(6*4))
+						value1457 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option1459 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option1459 = witTypes.None[string]()
+						case 1:
+							value1458 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option1459 = witTypes.Some[string](value1458)
+						default:
+							panic("unreachable")
+						}
+
+						result1460 = append(result1460, golem_core_types.SchemaTypeDef{value1457, option1459, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result1484 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))), index*(16+4*4))
+						var variant1483 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value1461 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeStringValue(value1461)
+
+						case 13:
+							result1462 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1462 = append(result1462, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeRecordValue(result1462)
+
+						case 14:
+							var option1463 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option1463 = witTypes.None[int32]()
+							case 1:
+
+								option1463 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1463})
+
+						case 15:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result1464 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result1464 = append(result1464, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1464)
+
+						case 17:
+							result1465 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1465 = append(result1465, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeTupleValue(result1465)
+
+						case 18:
+							result1466 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1466 = append(result1466, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeListValue(result1466)
+
+						case 19:
+							result1467 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1467 = append(result1467, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1467)
+
+						case 20:
+							result1468 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result1468 = append(result1468, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeMapValue(result1468)
+
+						case 21:
+							var option1469 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1469 = witTypes.None[int32]()
+							case 1:
+
+								option1469 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeOptionValue(option1469)
+
+						case 22:
+							var variant1472 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option1470 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1470 = witTypes.None[int32]()
+								case 1:
+
+									option1470 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1472 = golem_core_types.MakeResultValuePayloadOkValue(option1470)
+
+							case 1:
+								var option1471 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1471 = witTypes.None[int32]()
+								case 1:
+
+									option1471 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1472 = golem_core_types.MakeResultValuePayloadErrValue(option1471)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeResultValue(variant1472)
+
+						case 23:
+							value1473 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1475 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1475 = witTypes.None[string]()
+							case 1:
+								value1474 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1475 = witTypes.Some[string](value1474)
+							default:
+								panic("unreachable")
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1473, option1475})
+
+						case 24:
+							value1476 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1478 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1478 = witTypes.None[string]()
+							case 1:
+								value1477 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1478 = witTypes.Some[string](value1477)
+							default:
+								panic("unreachable")
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1476, option1478})
+
+						case 25:
+							value1479 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1483 = golem_core_types.MakeSchemaValueNodePathValue(value1479)
+
+						case 26:
+							value1480 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeUrlValue(value1480)
+
+						case 27:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value1481 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1481})
+
+						case 30:
+							value1482 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1482, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result1484 = append(result1484, variant1483)
+					}
+
+					variant1695 = MakeAgentInvocationResultAgentInitialization(AgentInvocationOutputParameters{golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1456, result1460, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))}, golem_core_types.SchemaValueTree{result1484, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 8*4)))}}})
+
+				case 1:
+					result1660 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))), index*(56+22*4))
+						var variant1648 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option1491 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1491 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1486 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1486 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1485 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1485 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1485 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1485 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1486 = witTypes.Some[golem_core_types.NumericBound](variant1485)
+								default:
+									panic("unreachable")
+								}
+								var option1488 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1488 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1487 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1487 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1487 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1487 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1488 = witTypes.Some[golem_core_types.NumericBound](variant1487)
+								default:
+									panic("unreachable")
+								}
+								var option1490 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1490 = witTypes.None[string]()
+								case 1:
+									value1489 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1490 = witTypes.Some[string](value1489)
+								default:
+									panic("unreachable")
+								}
+
+								option1491 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1486, option1488, option1490})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyS8Type(option1491)
+
+						case 3:
+							var option1498 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1498 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1493 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1493 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1492 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1492 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1492 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1492 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1493 = witTypes.Some[golem_core_types.NumericBound](variant1492)
+								default:
+									panic("unreachable")
+								}
+								var option1495 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1495 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1494 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1494 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1494 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1494 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1495 = witTypes.Some[golem_core_types.NumericBound](variant1494)
+								default:
+									panic("unreachable")
+								}
+								var option1497 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1497 = witTypes.None[string]()
+								case 1:
+									value1496 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1497 = witTypes.Some[string](value1496)
+								default:
+									panic("unreachable")
+								}
+
+								option1498 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1493, option1495, option1497})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyS16Type(option1498)
+
+						case 4:
+							var option1505 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1505 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1500 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1500 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1499 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1499 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1499 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1499 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1500 = witTypes.Some[golem_core_types.NumericBound](variant1499)
+								default:
+									panic("unreachable")
+								}
+								var option1502 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1502 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1501 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1501 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1501 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1501 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1502 = witTypes.Some[golem_core_types.NumericBound](variant1501)
+								default:
+									panic("unreachable")
+								}
+								var option1504 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1504 = witTypes.None[string]()
+								case 1:
+									value1503 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1504 = witTypes.Some[string](value1503)
+								default:
+									panic("unreachable")
+								}
+
+								option1505 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1500, option1502, option1504})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyS32Type(option1505)
+
+						case 5:
+							var option1512 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1512 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1507 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1507 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1506 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1506 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1506 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1506 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1507 = witTypes.Some[golem_core_types.NumericBound](variant1506)
+								default:
+									panic("unreachable")
+								}
+								var option1509 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1509 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1508 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1508 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1508 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1508 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1509 = witTypes.Some[golem_core_types.NumericBound](variant1508)
+								default:
+									panic("unreachable")
+								}
+								var option1511 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1511 = witTypes.None[string]()
+								case 1:
+									value1510 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1511 = witTypes.Some[string](value1510)
+								default:
+									panic("unreachable")
+								}
+
+								option1512 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1507, option1509, option1511})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyS64Type(option1512)
+
+						case 6:
+							var option1519 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1519 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1514 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1514 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1513 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1513 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1513 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1513 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1514 = witTypes.Some[golem_core_types.NumericBound](variant1513)
+								default:
+									panic("unreachable")
+								}
+								var option1516 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1516 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1515 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1515 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1515 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1515 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1516 = witTypes.Some[golem_core_types.NumericBound](variant1515)
+								default:
+									panic("unreachable")
+								}
+								var option1518 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1518 = witTypes.None[string]()
+								case 1:
+									value1517 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1518 = witTypes.Some[string](value1517)
+								default:
+									panic("unreachable")
+								}
+
+								option1519 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1514, option1516, option1518})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyU8Type(option1519)
+
+						case 7:
+							var option1526 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1526 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1521 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1521 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1520 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1520 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1520 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1520 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1521 = witTypes.Some[golem_core_types.NumericBound](variant1520)
+								default:
+									panic("unreachable")
+								}
+								var option1523 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1523 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1522 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1522 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1522 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1522 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1523 = witTypes.Some[golem_core_types.NumericBound](variant1522)
+								default:
+									panic("unreachable")
+								}
+								var option1525 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1525 = witTypes.None[string]()
+								case 1:
+									value1524 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1525 = witTypes.Some[string](value1524)
+								default:
+									panic("unreachable")
+								}
+
+								option1526 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1521, option1523, option1525})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyU16Type(option1526)
+
+						case 8:
+							var option1533 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1533 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1528 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1528 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1527 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1527 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1527 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1527 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1528 = witTypes.Some[golem_core_types.NumericBound](variant1527)
+								default:
+									panic("unreachable")
+								}
+								var option1530 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1530 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1529 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1529 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1529 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1529 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1530 = witTypes.Some[golem_core_types.NumericBound](variant1529)
+								default:
+									panic("unreachable")
+								}
+								var option1532 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1532 = witTypes.None[string]()
+								case 1:
+									value1531 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1532 = witTypes.Some[string](value1531)
+								default:
+									panic("unreachable")
+								}
+
+								option1533 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1528, option1530, option1532})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyU32Type(option1533)
+
+						case 9:
+							var option1540 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1540 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1535 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1535 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1534 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1534 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1534 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1534 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1535 = witTypes.Some[golem_core_types.NumericBound](variant1534)
+								default:
+									panic("unreachable")
+								}
+								var option1537 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1537 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1536 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1536 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1536 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1536 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1537 = witTypes.Some[golem_core_types.NumericBound](variant1536)
+								default:
+									panic("unreachable")
+								}
+								var option1539 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1539 = witTypes.None[string]()
+								case 1:
+									value1538 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1539 = witTypes.Some[string](value1538)
+								default:
+									panic("unreachable")
+								}
+
+								option1540 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1535, option1537, option1539})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyU64Type(option1540)
+
+						case 10:
+							var option1547 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1547 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1542 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1542 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1541 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1541 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1541 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1541 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1542 = witTypes.Some[golem_core_types.NumericBound](variant1541)
+								default:
+									panic("unreachable")
+								}
+								var option1544 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1544 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1543 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1543 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1543 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1543 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1544 = witTypes.Some[golem_core_types.NumericBound](variant1543)
+								default:
+									panic("unreachable")
+								}
+								var option1546 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1546 = witTypes.None[string]()
+								case 1:
+									value1545 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1546 = witTypes.Some[string](value1545)
+								default:
+									panic("unreachable")
+								}
+
+								option1547 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1542, option1544, option1546})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyF32Type(option1547)
+
+						case 11:
+							var option1554 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1554 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1549 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1549 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1548 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1548 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1548 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1548 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1549 = witTypes.Some[golem_core_types.NumericBound](variant1548)
+								default:
+									panic("unreachable")
+								}
+								var option1551 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1551 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1550 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1550 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1550 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1550 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1551 = witTypes.Some[golem_core_types.NumericBound](variant1550)
+								default:
+									panic("unreachable")
+								}
+								var option1553 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1553 = witTypes.None[string]()
+								case 1:
+									value1552 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1553 = witTypes.Some[string](value1552)
+								default:
+									panic("unreachable")
+								}
+
+								option1554 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1549, option1551, option1553})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyF64Type(option1554)
+
+						case 12:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result1567 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value1555 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1557 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option1557 = witTypes.None[string]()
+								case 1:
+									value1556 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option1557 = witTypes.Some[string](value1556)
+								default:
+									panic("unreachable")
+								}
+								result1559 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value1558 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1559 = append(result1559, value1558)
+								}
+
+								result1561 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value1560 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1561 = append(result1561, value1560)
+								}
+
+								var option1563 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option1563 = witTypes.None[string]()
+								case 1:
+									value1562 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option1563 = witTypes.Some[string](value1562)
+								default:
+									panic("unreachable")
+								}
+								var option1566 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option1566 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1565 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant1565 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1565 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1565 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1564 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant1565 = golem_core_types.MakeRoleOther(value1564)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1566 = witTypes.Some[golem_core_types.Role](variant1565)
+								default:
+									panic("unreachable")
+								}
+
+								result1567 = append(result1567, golem_core_types.NamedFieldType{value1555, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1557, result1559, result1561, option1563, option1566}})
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyRecordType(result1567)
+
+						case 15:
+							result1581 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value1568 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1569 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option1569 = witTypes.None[int32]()
+								case 1:
+
+									option1569 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option1571 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option1571 = witTypes.None[string]()
+								case 1:
+									value1570 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option1571 = witTypes.Some[string](value1570)
+								default:
+									panic("unreachable")
+								}
+								result1573 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1572 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1573 = append(result1573, value1572)
+								}
+
+								result1575 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value1574 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1575 = append(result1575, value1574)
+								}
+
+								var option1577 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option1577 = witTypes.None[string]()
+								case 1:
+									value1576 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option1577 = witTypes.Some[string](value1576)
+								default:
+									panic("unreachable")
+								}
+								var option1580 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option1580 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1579 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant1579 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1579 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1579 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1578 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant1579 = golem_core_types.MakeRoleOther(value1578)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1580 = witTypes.Some[golem_core_types.Role](variant1579)
+								default:
+									panic("unreachable")
+								}
+
+								result1581 = append(result1581, golem_core_types.VariantCaseType{value1568, option1569, golem_core_types.MetadataEnvelope{option1571, result1573, result1575, option1577, option1580}})
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyVariantType(result1581)
+
+						case 16:
+							result1583 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1582 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1583 = append(result1583, value1582)
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyEnumType(result1583)
+
+						case 17:
+							result1585 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1584 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1585 = append(result1585, value1584)
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1585)
+
+						case 18:
+							result1586 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1586 = append(result1586, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyTupleType(result1586)
+
+						case 19:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option1587 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1587 = witTypes.None[int32]()
+							case 1:
+
+								option1587 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option1588 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option1588 = witTypes.None[int32]()
+							case 1:
+
+								option1588 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1587, option1588})
+
+						case 24:
+							var option1591 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1591 = witTypes.None[[]string]()
+							case 1:
+								result1590 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1589 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1590 = append(result1590, value1589)
+								}
+
+								option1591 = witTypes.Some[[]string](result1590)
+							default:
+								panic("unreachable")
+							}
+							var option1592 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1592 = witTypes.None[uint32]()
+							case 1:
+
+								option1592 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1593 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1593 = witTypes.None[uint32]()
+							case 1:
+
+								option1593 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1595 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option1595 = witTypes.None[string]()
+							case 1:
+								value1594 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option1595 = witTypes.Some[string](value1594)
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1591, option1592, option1593, option1595})
+
+						case 25:
+							var option1598 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1598 = witTypes.None[[]string]()
+							case 1:
+								result1597 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1596 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1597 = append(result1597, value1596)
+								}
+
+								option1598 = witTypes.Some[[]string](result1597)
+							default:
+								panic("unreachable")
+							}
+							var option1599 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1599 = witTypes.None[uint32]()
+							case 1:
+
+								option1599 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1600 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1600 = witTypes.None[uint32]()
+							case 1:
+
+								option1600 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1598, option1599, option1600})
+
+						case 26:
+							var option1603 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1603 = witTypes.None[[]string]()
+							case 1:
+								result1602 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value1601 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1602 = append(result1602, value1601)
+								}
+
+								option1603 = witTypes.Some[[]string](result1602)
+							default:
+								panic("unreachable")
+							}
+							var option1606 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1606 = witTypes.None[[]string]()
+							case 1:
+								result1605 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1604 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1605 = append(result1605, value1604)
+								}
+
+								option1606 = witTypes.Some[[]string](result1605)
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option1603, option1606})
+
+						case 27:
+							var option1609 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1609 = witTypes.None[[]string]()
+							case 1:
+								result1608 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1607 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1608 = append(result1608, value1607)
+								}
+
+								option1609 = witTypes.Some[[]string](result1608)
+							default:
+								panic("unreachable")
+							}
+							var option1612 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1612 = witTypes.None[[]string]()
+							case 1:
+								result1611 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value1610 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1611 = append(result1611, value1610)
+								}
+
+								option1612 = witTypes.Some[[]string](result1611)
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1609, option1612})
+
+						case 28:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value1613 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result1615 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value1614 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1615 = append(result1615, value1614)
+							}
+
+							var option1617 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1617 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1616 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option1617 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value1616})
+							default:
+								panic("unreachable")
+							}
+							var option1619 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option1619 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1618 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option1619 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value1618})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1613, result1615, option1617, option1619})
+
+						case 31:
+							result1641 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value1620 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant1629 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value1621 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1629 = golem_core_types.MakeDiscriminatorRulePrefix(value1621)
+
+								case 1:
+									value1622 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1629 = golem_core_types.MakeDiscriminatorRuleSuffix(value1622)
+
+								case 2:
+									value1623 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1629 = golem_core_types.MakeDiscriminatorRuleContains(value1623)
+
+								case 3:
+									value1624 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1629 = golem_core_types.MakeDiscriminatorRuleRegex(value1624)
+
+								case 4:
+									value1625 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option1627 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option1627 = witTypes.None[string]()
+									case 1:
+										value1626 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option1627 = witTypes.Some[string](value1626)
+									default:
+										panic("unreachable")
+									}
+
+									variant1629 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1625, option1627})
+
+								case 5:
+									value1628 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1629 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1628)
+
+								default:
+									panic("unreachable")
+								}
+								var option1631 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option1631 = witTypes.None[string]()
+								case 1:
+									value1630 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option1631 = witTypes.Some[string](value1630)
+								default:
+									panic("unreachable")
+								}
+								result1633 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value1632 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1633 = append(result1633, value1632)
+								}
+
+								result1635 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value1634 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1635 = append(result1635, value1634)
+								}
+
+								var option1637 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option1637 = witTypes.None[string]()
+								case 1:
+									value1636 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option1637 = witTypes.Some[string](value1636)
+								default:
+									panic("unreachable")
+								}
+								var option1640 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option1640 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1639 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant1639 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1639 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1639 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1638 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant1639 = golem_core_types.MakeRoleOther(value1638)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1640 = witTypes.Some[golem_core_types.Role](variant1639)
+								default:
+									panic("unreachable")
+								}
+
+								result1641 = append(result1641, golem_core_types.UnionBranch{value1620, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1629, golem_core_types.MetadataEnvelope{option1631, result1633, result1635, option1637, option1640}})
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1641})
+
+						case 32:
+							var option1643 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1643 = witTypes.None[string]()
+							case 1:
+								value1642 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option1643 = witTypes.Some[string](value1642)
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1643})
+
+						case 33:
+							var option1645 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1645 = witTypes.None[string]()
+							case 1:
+								value1644 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option1645 = witTypes.Some[string](value1644)
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1645})
+
+						case 34:
+							var option1646 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1646 = witTypes.None[int32]()
+							case 1:
+
+								option1646 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyFutureType(option1646)
+
+						case 35:
+							var option1647 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1647 = witTypes.None[int32]()
+							case 1:
+
+								option1647 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyStreamType(option1647)
+
+						default:
+							panic("unreachable")
+						}
+						var option1650 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option1650 = witTypes.None[string]()
+						case 1:
+							value1649 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option1650 = witTypes.Some[string](value1649)
+						default:
+							panic("unreachable")
+						}
+						result1652 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value1651 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1652 = append(result1652, value1651)
+						}
+
+						result1654 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value1653 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1654 = append(result1654, value1653)
+						}
+
+						var option1656 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option1656 = witTypes.None[string]()
+						case 1:
+							value1655 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option1656 = witTypes.Some[string](value1655)
+						default:
+							panic("unreachable")
+						}
+						var option1659 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option1659 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant1658 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant1658 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant1658 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant1658 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value1657 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant1658 = golem_core_types.MakeRoleOther(value1657)
+
+							default:
+								panic("unreachable")
+							}
+
+							option1659 = witTypes.Some[golem_core_types.Role](variant1658)
+						default:
+							panic("unreachable")
+						}
+
+						result1660 = append(result1660, golem_core_types.SchemaTypeNode{variant1648, golem_core_types.MetadataEnvelope{option1650, result1652, result1654, option1656, option1659}})
+					}
+
+					result1664 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))))), index*(6*4))
+						value1661 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option1663 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option1663 = witTypes.None[string]()
+						case 1:
+							value1662 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option1663 = witTypes.Some[string](value1662)
+						default:
+							panic("unreachable")
+						}
+
+						result1664 = append(result1664, golem_core_types.SchemaTypeDef{value1661, option1663, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result1688 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))), index*(16+4*4))
+						var variant1687 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value1665 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeStringValue(value1665)
+
+						case 13:
+							result1666 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1666 = append(result1666, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeRecordValue(result1666)
+
+						case 14:
+							var option1667 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option1667 = witTypes.None[int32]()
+							case 1:
+
+								option1667 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1667})
+
+						case 15:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result1668 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result1668 = append(result1668, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1668)
+
+						case 17:
+							result1669 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1669 = append(result1669, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeTupleValue(result1669)
+
+						case 18:
+							result1670 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1670 = append(result1670, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeListValue(result1670)
+
+						case 19:
+							result1671 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1671 = append(result1671, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1671)
+
+						case 20:
+							result1672 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result1672 = append(result1672, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeMapValue(result1672)
+
+						case 21:
+							var option1673 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1673 = witTypes.None[int32]()
+							case 1:
+
+								option1673 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeOptionValue(option1673)
+
+						case 22:
+							var variant1676 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option1674 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1674 = witTypes.None[int32]()
+								case 1:
+
+									option1674 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1676 = golem_core_types.MakeResultValuePayloadOkValue(option1674)
+
+							case 1:
+								var option1675 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1675 = witTypes.None[int32]()
+								case 1:
+
+									option1675 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1676 = golem_core_types.MakeResultValuePayloadErrValue(option1675)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeResultValue(variant1676)
+
+						case 23:
+							value1677 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1679 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1679 = witTypes.None[string]()
+							case 1:
+								value1678 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1679 = witTypes.Some[string](value1678)
+							default:
+								panic("unreachable")
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1677, option1679})
+
+						case 24:
+							value1680 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1682 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1682 = witTypes.None[string]()
+							case 1:
+								value1681 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1682 = witTypes.Some[string](value1681)
+							default:
+								panic("unreachable")
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1680, option1682})
+
+						case 25:
+							value1683 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1687 = golem_core_types.MakeSchemaValueNodePathValue(value1683)
+
+						case 26:
+							value1684 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeUrlValue(value1684)
+
+						case 27:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value1685 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1685})
+
+						case 30:
+							value1686 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1686, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result1688 = append(result1688, variant1687)
+					}
+
+					variant1695 = MakeAgentInvocationResultAgentMethod(AgentInvocationOutputParameters{golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1660, result1664, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))}, golem_core_types.SchemaValueTree{result1688, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 8*4)))}}})
+
+				case 2:
+
+					variant1695 = MakeAgentInvocationResultManualUpdate()
+
+				case 3:
+					var option1690 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) {
+					case 0:
+
+						option1690 = witTypes.None[string]()
+					case 1:
+						value1689 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))))
+
+						option1690 = witTypes.Some[string](value1689)
+					default:
+						panic("unreachable")
+					}
+
+					variant1695 = MakeAgentInvocationResultLoadSnapshot(FallibleResultParameters{option1690})
+
+				case 4:
+					value1691 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4))))
+					value1692 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+					variant1695 = MakeAgentInvocationResultSaveSnapshot(SaveSnapshotResultParameters{SnapshotData{value1691, value1692}})
+
+				case 5:
+					var option1694 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) {
+					case 0:
+
+						option1694 = witTypes.None[string]()
+					case 1:
+						value1693 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))))
+
+						option1694 = witTypes.Some[string](value1693)
+					default:
+						panic("unreachable")
+					}
+
+					variant1695 = MakeAgentInvocationResultProcessOplogEntries(FallibleResultParameters{option1694})
+
+				default:
+					panic("unreachable")
+				}
+				var option1697 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 9*4)))) {
+				case 0:
+
+					option1697 = witTypes.None[string]()
+				case 1:
+					value1696 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 11*4))))
+
+					option1697 = witTypes.Some[string](value1696)
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryAgentInvocationFinished(AgentInvocationFinishedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, variant1695, option1697, *(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 12*4))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))))})
+
+			case 6:
+
+				variant2471 = MakePublicOplogEntrySuspend(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}})
+
+			case 7:
+				value1698 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+				var option1701 witTypes.Option[RetryPolicyState]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) {
+				case 0:
+
+					option1701 = witTypes.None[RetryPolicyState]()
+				case 1:
+					result1700 := make([]StateNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))), index*16)
+						var variant1699 StateNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1699 = MakeStateNodeCounter(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4))))
+
+						case 1:
+
+							variant1699 = MakeStateNodeTerminal()
+
+						case 2:
+
+							variant1699 = MakeStateNodeWrapper(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						case 3:
+
+							variant1699 = MakeStateNodeCountBox(CountBoxState{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 4:
+
+							variant1699 = MakeStateNodeAndThen(AndThenState{*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) != 0)})
+
+						case 5:
+
+							variant1699 = MakeStateNodePair(PairState{*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						default:
+							panic("unreachable")
+						}
+
+						result1700 = append(result1700, variant1699)
+					}
+
+					option1701 = witTypes.Some[RetryPolicyState](RetryPolicyState{result1700})
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryError(ErrorParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, value1698, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))) != 0), option1701})
+
+			case 8:
+
+				variant2471 = MakePublicOplogEntryNoOp(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}})
+
+			case 9:
+
+				variant2471 = MakePublicOplogEntryJump(JumpParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, OplogRegion{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}})
+
+			case 10:
+
+				variant2471 = MakePublicOplogEntryInterrupted(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}})
+
+			case 11:
+
+				variant2471 = MakePublicOplogEntryExited(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}})
+
+			case 12:
+
+				variant2471 = MakePublicOplogEntryBeginAtomicRegion(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}})
+
+			case 13:
+
+				variant2471 = MakePublicOplogEntryEndAtomicRegion(EndAtomicRegionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24)))})
+
+			case 14:
+				var variant2146 AgentInvocation
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+				case 0:
+					value1702 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+					result1878 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))), index*(56+22*4))
+						var variant1866 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option1709 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1709 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1704 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1704 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1703 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1703 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1703 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1703 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1704 = witTypes.Some[golem_core_types.NumericBound](variant1703)
+								default:
+									panic("unreachable")
+								}
+								var option1706 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1706 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1705 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1705 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1705 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1705 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1706 = witTypes.Some[golem_core_types.NumericBound](variant1705)
+								default:
+									panic("unreachable")
+								}
+								var option1708 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1708 = witTypes.None[string]()
+								case 1:
+									value1707 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1708 = witTypes.Some[string](value1707)
+								default:
+									panic("unreachable")
+								}
+
+								option1709 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1704, option1706, option1708})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyS8Type(option1709)
+
+						case 3:
+							var option1716 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1716 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1711 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1711 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1710 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1710 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1710 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1710 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1711 = witTypes.Some[golem_core_types.NumericBound](variant1710)
+								default:
+									panic("unreachable")
+								}
+								var option1713 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1713 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1712 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1712 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1712 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1712 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1713 = witTypes.Some[golem_core_types.NumericBound](variant1712)
+								default:
+									panic("unreachable")
+								}
+								var option1715 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1715 = witTypes.None[string]()
+								case 1:
+									value1714 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1715 = witTypes.Some[string](value1714)
+								default:
+									panic("unreachable")
+								}
+
+								option1716 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1711, option1713, option1715})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyS16Type(option1716)
+
+						case 4:
+							var option1723 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1723 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1718 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1718 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1717 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1717 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1717 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1717 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1718 = witTypes.Some[golem_core_types.NumericBound](variant1717)
+								default:
+									panic("unreachable")
+								}
+								var option1720 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1720 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1719 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1719 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1719 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1719 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1720 = witTypes.Some[golem_core_types.NumericBound](variant1719)
+								default:
+									panic("unreachable")
+								}
+								var option1722 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1722 = witTypes.None[string]()
+								case 1:
+									value1721 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1722 = witTypes.Some[string](value1721)
+								default:
+									panic("unreachable")
+								}
+
+								option1723 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1718, option1720, option1722})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyS32Type(option1723)
+
+						case 5:
+							var option1730 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1730 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1725 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1725 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1724 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1724 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1724 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1724 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1725 = witTypes.Some[golem_core_types.NumericBound](variant1724)
+								default:
+									panic("unreachable")
+								}
+								var option1727 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1727 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1726 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1726 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1726 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1726 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1727 = witTypes.Some[golem_core_types.NumericBound](variant1726)
+								default:
+									panic("unreachable")
+								}
+								var option1729 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1729 = witTypes.None[string]()
+								case 1:
+									value1728 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1729 = witTypes.Some[string](value1728)
+								default:
+									panic("unreachable")
+								}
+
+								option1730 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1725, option1727, option1729})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyS64Type(option1730)
+
+						case 6:
+							var option1737 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1737 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1732 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1732 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1731 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1731 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1731 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1731 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1732 = witTypes.Some[golem_core_types.NumericBound](variant1731)
+								default:
+									panic("unreachable")
+								}
+								var option1734 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1734 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1733 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1733 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1733 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1733 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1734 = witTypes.Some[golem_core_types.NumericBound](variant1733)
+								default:
+									panic("unreachable")
+								}
+								var option1736 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1736 = witTypes.None[string]()
+								case 1:
+									value1735 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1736 = witTypes.Some[string](value1735)
+								default:
+									panic("unreachable")
+								}
+
+								option1737 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1732, option1734, option1736})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyU8Type(option1737)
+
+						case 7:
+							var option1744 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1744 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1739 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1739 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1738 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1738 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1738 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1738 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1739 = witTypes.Some[golem_core_types.NumericBound](variant1738)
+								default:
+									panic("unreachable")
+								}
+								var option1741 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1741 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1740 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1740 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1740 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1740 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1741 = witTypes.Some[golem_core_types.NumericBound](variant1740)
+								default:
+									panic("unreachable")
+								}
+								var option1743 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1743 = witTypes.None[string]()
+								case 1:
+									value1742 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1743 = witTypes.Some[string](value1742)
+								default:
+									panic("unreachable")
+								}
+
+								option1744 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1739, option1741, option1743})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyU16Type(option1744)
+
+						case 8:
+							var option1751 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1751 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1746 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1746 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1745 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1745 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1745 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1745 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1746 = witTypes.Some[golem_core_types.NumericBound](variant1745)
+								default:
+									panic("unreachable")
+								}
+								var option1748 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1748 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1747 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1747 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1747 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1747 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1748 = witTypes.Some[golem_core_types.NumericBound](variant1747)
+								default:
+									panic("unreachable")
+								}
+								var option1750 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1750 = witTypes.None[string]()
+								case 1:
+									value1749 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1750 = witTypes.Some[string](value1749)
+								default:
+									panic("unreachable")
+								}
+
+								option1751 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1746, option1748, option1750})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyU32Type(option1751)
+
+						case 9:
+							var option1758 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1758 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1753 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1753 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1752 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1752 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1752 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1752 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1753 = witTypes.Some[golem_core_types.NumericBound](variant1752)
+								default:
+									panic("unreachable")
+								}
+								var option1755 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1755 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1754 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1754 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1754 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1754 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1755 = witTypes.Some[golem_core_types.NumericBound](variant1754)
+								default:
+									panic("unreachable")
+								}
+								var option1757 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1757 = witTypes.None[string]()
+								case 1:
+									value1756 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1757 = witTypes.Some[string](value1756)
+								default:
+									panic("unreachable")
+								}
+
+								option1758 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1753, option1755, option1757})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyU64Type(option1758)
+
+						case 10:
+							var option1765 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1765 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1760 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1760 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1759 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1759 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1759 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1759 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1760 = witTypes.Some[golem_core_types.NumericBound](variant1759)
+								default:
+									panic("unreachable")
+								}
+								var option1762 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1762 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1761 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1761 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1761 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1761 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1762 = witTypes.Some[golem_core_types.NumericBound](variant1761)
+								default:
+									panic("unreachable")
+								}
+								var option1764 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1764 = witTypes.None[string]()
+								case 1:
+									value1763 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1764 = witTypes.Some[string](value1763)
+								default:
+									panic("unreachable")
+								}
+
+								option1765 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1760, option1762, option1764})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyF32Type(option1765)
+
+						case 11:
+							var option1772 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1772 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1767 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1767 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1766 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1766 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1766 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1766 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1767 = witTypes.Some[golem_core_types.NumericBound](variant1766)
+								default:
+									panic("unreachable")
+								}
+								var option1769 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1769 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1768 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1768 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1768 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1768 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1769 = witTypes.Some[golem_core_types.NumericBound](variant1768)
+								default:
+									panic("unreachable")
+								}
+								var option1771 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1771 = witTypes.None[string]()
+								case 1:
+									value1770 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1771 = witTypes.Some[string](value1770)
+								default:
+									panic("unreachable")
+								}
+
+								option1772 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1767, option1769, option1771})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyF64Type(option1772)
+
+						case 12:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result1785 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value1773 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1775 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option1775 = witTypes.None[string]()
+								case 1:
+									value1774 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option1775 = witTypes.Some[string](value1774)
+								default:
+									panic("unreachable")
+								}
+								result1777 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value1776 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1777 = append(result1777, value1776)
+								}
+
+								result1779 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value1778 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1779 = append(result1779, value1778)
+								}
+
+								var option1781 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option1781 = witTypes.None[string]()
+								case 1:
+									value1780 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option1781 = witTypes.Some[string](value1780)
+								default:
+									panic("unreachable")
+								}
+								var option1784 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option1784 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1783 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant1783 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1783 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1783 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1782 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant1783 = golem_core_types.MakeRoleOther(value1782)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1784 = witTypes.Some[golem_core_types.Role](variant1783)
+								default:
+									panic("unreachable")
+								}
+
+								result1785 = append(result1785, golem_core_types.NamedFieldType{value1773, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1775, result1777, result1779, option1781, option1784}})
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyRecordType(result1785)
+
+						case 15:
+							result1799 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value1786 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1787 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option1787 = witTypes.None[int32]()
+								case 1:
+
+									option1787 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option1789 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option1789 = witTypes.None[string]()
+								case 1:
+									value1788 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option1789 = witTypes.Some[string](value1788)
+								default:
+									panic("unreachable")
+								}
+								result1791 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1790 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1791 = append(result1791, value1790)
+								}
+
+								result1793 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value1792 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1793 = append(result1793, value1792)
+								}
+
+								var option1795 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option1795 = witTypes.None[string]()
+								case 1:
+									value1794 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option1795 = witTypes.Some[string](value1794)
+								default:
+									panic("unreachable")
+								}
+								var option1798 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option1798 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1797 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant1797 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1797 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1797 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1796 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant1797 = golem_core_types.MakeRoleOther(value1796)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1798 = witTypes.Some[golem_core_types.Role](variant1797)
+								default:
+									panic("unreachable")
+								}
+
+								result1799 = append(result1799, golem_core_types.VariantCaseType{value1786, option1787, golem_core_types.MetadataEnvelope{option1789, result1791, result1793, option1795, option1798}})
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyVariantType(result1799)
+
+						case 16:
+							result1801 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1800 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1801 = append(result1801, value1800)
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyEnumType(result1801)
+
+						case 17:
+							result1803 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1802 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1803 = append(result1803, value1802)
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1803)
+
+						case 18:
+							result1804 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1804 = append(result1804, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyTupleType(result1804)
+
+						case 19:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option1805 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1805 = witTypes.None[int32]()
+							case 1:
+
+								option1805 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option1806 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option1806 = witTypes.None[int32]()
+							case 1:
+
+								option1806 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1805, option1806})
+
+						case 24:
+							var option1809 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1809 = witTypes.None[[]string]()
+							case 1:
+								result1808 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1807 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1808 = append(result1808, value1807)
+								}
+
+								option1809 = witTypes.Some[[]string](result1808)
+							default:
+								panic("unreachable")
+							}
+							var option1810 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1810 = witTypes.None[uint32]()
+							case 1:
+
+								option1810 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1811 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1811 = witTypes.None[uint32]()
+							case 1:
+
+								option1811 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1813 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option1813 = witTypes.None[string]()
+							case 1:
+								value1812 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option1813 = witTypes.Some[string](value1812)
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1809, option1810, option1811, option1813})
+
+						case 25:
+							var option1816 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1816 = witTypes.None[[]string]()
+							case 1:
+								result1815 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1814 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1815 = append(result1815, value1814)
+								}
+
+								option1816 = witTypes.Some[[]string](result1815)
+							default:
+								panic("unreachable")
+							}
+							var option1817 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1817 = witTypes.None[uint32]()
+							case 1:
+
+								option1817 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1818 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1818 = witTypes.None[uint32]()
+							case 1:
+
+								option1818 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1816, option1817, option1818})
+
+						case 26:
+							var option1821 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1821 = witTypes.None[[]string]()
+							case 1:
+								result1820 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value1819 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1820 = append(result1820, value1819)
+								}
+
+								option1821 = witTypes.Some[[]string](result1820)
+							default:
+								panic("unreachable")
+							}
+							var option1824 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1824 = witTypes.None[[]string]()
+							case 1:
+								result1823 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1822 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1823 = append(result1823, value1822)
+								}
+
+								option1824 = witTypes.Some[[]string](result1823)
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option1821, option1824})
+
+						case 27:
+							var option1827 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1827 = witTypes.None[[]string]()
+							case 1:
+								result1826 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1825 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1826 = append(result1826, value1825)
+								}
+
+								option1827 = witTypes.Some[[]string](result1826)
+							default:
+								panic("unreachable")
+							}
+							var option1830 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1830 = witTypes.None[[]string]()
+							case 1:
+								result1829 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value1828 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1829 = append(result1829, value1828)
+								}
+
+								option1830 = witTypes.Some[[]string](result1829)
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1827, option1830})
+
+						case 28:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value1831 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result1833 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value1832 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1833 = append(result1833, value1832)
+							}
+
+							var option1835 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1835 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1834 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option1835 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value1834})
+							default:
+								panic("unreachable")
+							}
+							var option1837 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option1837 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1836 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option1837 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value1836})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1831, result1833, option1835, option1837})
+
+						case 31:
+							result1859 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value1838 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant1847 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value1839 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1847 = golem_core_types.MakeDiscriminatorRulePrefix(value1839)
+
+								case 1:
+									value1840 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1847 = golem_core_types.MakeDiscriminatorRuleSuffix(value1840)
+
+								case 2:
+									value1841 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1847 = golem_core_types.MakeDiscriminatorRuleContains(value1841)
+
+								case 3:
+									value1842 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1847 = golem_core_types.MakeDiscriminatorRuleRegex(value1842)
+
+								case 4:
+									value1843 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option1845 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option1845 = witTypes.None[string]()
+									case 1:
+										value1844 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option1845 = witTypes.Some[string](value1844)
+									default:
+										panic("unreachable")
+									}
+
+									variant1847 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1843, option1845})
+
+								case 5:
+									value1846 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1847 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1846)
+
+								default:
+									panic("unreachable")
+								}
+								var option1849 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option1849 = witTypes.None[string]()
+								case 1:
+									value1848 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option1849 = witTypes.Some[string](value1848)
+								default:
+									panic("unreachable")
+								}
+								result1851 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value1850 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1851 = append(result1851, value1850)
+								}
+
+								result1853 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value1852 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1853 = append(result1853, value1852)
+								}
+
+								var option1855 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option1855 = witTypes.None[string]()
+								case 1:
+									value1854 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option1855 = witTypes.Some[string](value1854)
+								default:
+									panic("unreachable")
+								}
+								var option1858 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option1858 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1857 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant1857 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1857 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1857 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1856 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant1857 = golem_core_types.MakeRoleOther(value1856)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1858 = witTypes.Some[golem_core_types.Role](variant1857)
+								default:
+									panic("unreachable")
+								}
+
+								result1859 = append(result1859, golem_core_types.UnionBranch{value1838, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1847, golem_core_types.MetadataEnvelope{option1849, result1851, result1853, option1855, option1858}})
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1859})
+
+						case 32:
+							var option1861 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1861 = witTypes.None[string]()
+							case 1:
+								value1860 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option1861 = witTypes.Some[string](value1860)
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1861})
+
+						case 33:
+							var option1863 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1863 = witTypes.None[string]()
+							case 1:
+								value1862 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option1863 = witTypes.Some[string](value1862)
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1863})
+
+						case 34:
+							var option1864 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1864 = witTypes.None[int32]()
+							case 1:
+
+								option1864 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyFutureType(option1864)
+
+						case 35:
+							var option1865 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1865 = witTypes.None[int32]()
+							case 1:
+
+								option1865 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyStreamType(option1865)
+
+						default:
+							panic("unreachable")
+						}
+						var option1868 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option1868 = witTypes.None[string]()
+						case 1:
+							value1867 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option1868 = witTypes.Some[string](value1867)
+						default:
+							panic("unreachable")
+						}
+						result1870 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value1869 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1870 = append(result1870, value1869)
+						}
+
+						result1872 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value1871 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1872 = append(result1872, value1871)
+						}
+
+						var option1874 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option1874 = witTypes.None[string]()
+						case 1:
+							value1873 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option1874 = witTypes.Some[string](value1873)
+						default:
+							panic("unreachable")
+						}
+						var option1877 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option1877 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant1876 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant1876 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant1876 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant1876 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value1875 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant1876 = golem_core_types.MakeRoleOther(value1875)
+
+							default:
+								panic("unreachable")
+							}
+
+							option1877 = witTypes.Some[golem_core_types.Role](variant1876)
+						default:
+							panic("unreachable")
+						}
+
+						result1878 = append(result1878, golem_core_types.SchemaTypeNode{variant1866, golem_core_types.MetadataEnvelope{option1868, result1870, result1872, option1874, option1877}})
+					}
+
+					result1882 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))), index*(6*4))
+						value1879 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option1881 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option1881 = witTypes.None[string]()
+						case 1:
+							value1880 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option1881 = witTypes.Some[string](value1880)
+						default:
+							panic("unreachable")
+						}
+
+						result1882 = append(result1882, golem_core_types.SchemaTypeDef{value1879, option1881, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result1906 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))), index*(16+4*4))
+						var variant1905 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value1883 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeStringValue(value1883)
+
+						case 13:
+							result1884 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1884 = append(result1884, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeRecordValue(result1884)
+
+						case 14:
+							var option1885 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option1885 = witTypes.None[int32]()
+							case 1:
+
+								option1885 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1885})
+
+						case 15:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result1886 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result1886 = append(result1886, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1886)
+
+						case 17:
+							result1887 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1887 = append(result1887, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeTupleValue(result1887)
+
+						case 18:
+							result1888 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1888 = append(result1888, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeListValue(result1888)
+
+						case 19:
+							result1889 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1889 = append(result1889, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1889)
+
+						case 20:
+							result1890 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result1890 = append(result1890, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeMapValue(result1890)
+
+						case 21:
+							var option1891 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1891 = witTypes.None[int32]()
+							case 1:
+
+								option1891 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeOptionValue(option1891)
+
+						case 22:
+							var variant1894 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option1892 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1892 = witTypes.None[int32]()
+								case 1:
+
+									option1892 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1894 = golem_core_types.MakeResultValuePayloadOkValue(option1892)
+
+							case 1:
+								var option1893 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1893 = witTypes.None[int32]()
+								case 1:
+
+									option1893 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1894 = golem_core_types.MakeResultValuePayloadErrValue(option1893)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeResultValue(variant1894)
+
+						case 23:
+							value1895 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1897 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1897 = witTypes.None[string]()
+							case 1:
+								value1896 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1897 = witTypes.Some[string](value1896)
+							default:
+								panic("unreachable")
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1895, option1897})
+
+						case 24:
+							value1898 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1900 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1900 = witTypes.None[string]()
+							case 1:
+								value1899 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1900 = witTypes.Some[string](value1899)
+							default:
+								panic("unreachable")
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1898, option1900})
+
+						case 25:
+							value1901 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1905 = golem_core_types.MakeSchemaValueNodePathValue(value1901)
+
+						case 26:
+							value1902 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeUrlValue(value1902)
+
+						case 27:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value1903 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1903})
+
+						case 30:
+							value1904 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1904, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result1906 = append(result1906, variant1905)
+					}
+
+					value1907 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4))))
+					result1909 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))))), index*(2*4))
+						value1908 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result1909 = append(result1909, value1908)
+					}
+
+					result1921 := make([][]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 14*4))))), index*(2*4))
+						result1920 := make([]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*(56+6*4))
+							var variant1919 SpanData
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value1910 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var option1912 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) {
+								case 0:
+
+									option1912 = witTypes.None[string]()
+								case 1:
+									value1911 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+									option1912 = witTypes.Some[string](value1911)
+								default:
+									panic("unreachable")
+								}
+								var option1913 witTypes.Option[uint64]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) {
+								case 0:
+
+									option1913 = witTypes.None[uint64]()
+								case 1:
+
+									option1913 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))))
+								default:
+									panic("unreachable")
+								}
+								result1917 := make([]golem_api_context.Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))), index*(5*4))
+									value1914 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+									var variant1916 golem_api_context.AttributeValue
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+									case 0:
+										value1915 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+										variant1916 = golem_api_context.MakeAttributeValueString(value1915)
+
+									default:
+										panic("unreachable")
+									}
+
+									result1917 = append(result1917, golem_api_context.Attribute{value1914, variant1916})
+								}
+
+								variant1919 = MakeSpanDataLocalSpan(LocalSpanData{value1910, wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))}, option1912, option1913, result1917, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)})
+
+							case 1:
+								value1918 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant1919 = MakeSpanDataExternalSpan(ExternalSpanData{value1918})
+
+							default:
+								panic("unreachable")
+							}
+
+							result1920 = append(result1920, variant1919)
+						}
+
+						result1921 = append(result1921, result1920)
+					}
+
+					variant2146 = MakeAgentInvocationAgentInitialization(AgentInitializationParameters{value1702, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1878, result1882, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))}, golem_core_types.SchemaValueTree{result1906, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4)))}}, value1907, result1909, result1921})
+
+				case 1:
+					value1922 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+					value1923 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+					result2099 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))), index*(56+22*4))
+						var variant2087 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option1930 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1930 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1925 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1925 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1924 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1924 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1924 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1924 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1925 = witTypes.Some[golem_core_types.NumericBound](variant1924)
+								default:
+									panic("unreachable")
+								}
+								var option1927 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1927 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1926 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1926 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1926 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1926 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1927 = witTypes.Some[golem_core_types.NumericBound](variant1926)
+								default:
+									panic("unreachable")
+								}
+								var option1929 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1929 = witTypes.None[string]()
+								case 1:
+									value1928 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1929 = witTypes.Some[string](value1928)
+								default:
+									panic("unreachable")
+								}
+
+								option1930 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1925, option1927, option1929})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyS8Type(option1930)
+
+						case 3:
+							var option1937 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1937 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1932 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1932 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1931 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1931 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1931 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1931 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1932 = witTypes.Some[golem_core_types.NumericBound](variant1931)
+								default:
+									panic("unreachable")
+								}
+								var option1934 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1934 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1933 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1933 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1933 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1933 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1934 = witTypes.Some[golem_core_types.NumericBound](variant1933)
+								default:
+									panic("unreachable")
+								}
+								var option1936 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1936 = witTypes.None[string]()
+								case 1:
+									value1935 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1936 = witTypes.Some[string](value1935)
+								default:
+									panic("unreachable")
+								}
+
+								option1937 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1932, option1934, option1936})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyS16Type(option1937)
+
+						case 4:
+							var option1944 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1944 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1939 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1939 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1938 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1938 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1938 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1938 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1939 = witTypes.Some[golem_core_types.NumericBound](variant1938)
+								default:
+									panic("unreachable")
+								}
+								var option1941 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1941 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1940 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1940 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1940 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1940 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1941 = witTypes.Some[golem_core_types.NumericBound](variant1940)
+								default:
+									panic("unreachable")
+								}
+								var option1943 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1943 = witTypes.None[string]()
+								case 1:
+									value1942 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1943 = witTypes.Some[string](value1942)
+								default:
+									panic("unreachable")
+								}
+
+								option1944 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1939, option1941, option1943})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyS32Type(option1944)
+
+						case 5:
+							var option1951 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1951 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1946 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1946 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1945 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1945 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1945 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1945 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1946 = witTypes.Some[golem_core_types.NumericBound](variant1945)
+								default:
+									panic("unreachable")
+								}
+								var option1948 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1948 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1947 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1947 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1947 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1947 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1948 = witTypes.Some[golem_core_types.NumericBound](variant1947)
+								default:
+									panic("unreachable")
+								}
+								var option1950 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1950 = witTypes.None[string]()
+								case 1:
+									value1949 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1950 = witTypes.Some[string](value1949)
+								default:
+									panic("unreachable")
+								}
+
+								option1951 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1946, option1948, option1950})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyS64Type(option1951)
+
+						case 6:
+							var option1958 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1958 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1953 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1953 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1952 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1952 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1952 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1952 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1953 = witTypes.Some[golem_core_types.NumericBound](variant1952)
+								default:
+									panic("unreachable")
+								}
+								var option1955 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1955 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1954 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1954 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1954 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1954 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1955 = witTypes.Some[golem_core_types.NumericBound](variant1954)
+								default:
+									panic("unreachable")
+								}
+								var option1957 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1957 = witTypes.None[string]()
+								case 1:
+									value1956 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1957 = witTypes.Some[string](value1956)
+								default:
+									panic("unreachable")
+								}
+
+								option1958 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1953, option1955, option1957})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyU8Type(option1958)
+
+						case 7:
+							var option1965 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1965 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1960 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1960 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1959 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1959 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1959 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1959 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1960 = witTypes.Some[golem_core_types.NumericBound](variant1959)
+								default:
+									panic("unreachable")
+								}
+								var option1962 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1962 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1961 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1961 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1961 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1961 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1962 = witTypes.Some[golem_core_types.NumericBound](variant1961)
+								default:
+									panic("unreachable")
+								}
+								var option1964 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1964 = witTypes.None[string]()
+								case 1:
+									value1963 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1964 = witTypes.Some[string](value1963)
+								default:
+									panic("unreachable")
+								}
+
+								option1965 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1960, option1962, option1964})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyU16Type(option1965)
+
+						case 8:
+							var option1972 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1972 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1967 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1967 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1966 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1966 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1966 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1966 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1967 = witTypes.Some[golem_core_types.NumericBound](variant1966)
+								default:
+									panic("unreachable")
+								}
+								var option1969 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1969 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1968 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1968 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1968 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1968 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1969 = witTypes.Some[golem_core_types.NumericBound](variant1968)
+								default:
+									panic("unreachable")
+								}
+								var option1971 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1971 = witTypes.None[string]()
+								case 1:
+									value1970 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1971 = witTypes.Some[string](value1970)
+								default:
+									panic("unreachable")
+								}
+
+								option1972 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1967, option1969, option1971})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyU32Type(option1972)
+
+						case 9:
+							var option1979 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1979 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1974 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1974 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1973 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1973 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1973 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1973 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1974 = witTypes.Some[golem_core_types.NumericBound](variant1973)
+								default:
+									panic("unreachable")
+								}
+								var option1976 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1976 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1975 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1975 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1975 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1975 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1976 = witTypes.Some[golem_core_types.NumericBound](variant1975)
+								default:
+									panic("unreachable")
+								}
+								var option1978 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1978 = witTypes.None[string]()
+								case 1:
+									value1977 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1978 = witTypes.Some[string](value1977)
+								default:
+									panic("unreachable")
+								}
+
+								option1979 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1974, option1976, option1978})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyU64Type(option1979)
+
+						case 10:
+							var option1986 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1986 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1981 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1981 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1980 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1980 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1980 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1980 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1981 = witTypes.Some[golem_core_types.NumericBound](variant1980)
+								default:
+									panic("unreachable")
+								}
+								var option1983 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1983 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1982 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1982 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1982 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1982 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1983 = witTypes.Some[golem_core_types.NumericBound](variant1982)
+								default:
+									panic("unreachable")
+								}
+								var option1985 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1985 = witTypes.None[string]()
+								case 1:
+									value1984 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1985 = witTypes.Some[string](value1984)
+								default:
+									panic("unreachable")
+								}
+
+								option1986 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1981, option1983, option1985})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyF32Type(option1986)
+
+						case 11:
+							var option1993 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1993 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1988 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1988 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1987 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1987 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1987 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1987 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1988 = witTypes.Some[golem_core_types.NumericBound](variant1987)
+								default:
+									panic("unreachable")
+								}
+								var option1990 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1990 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1989 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1989 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1989 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1989 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1990 = witTypes.Some[golem_core_types.NumericBound](variant1989)
+								default:
+									panic("unreachable")
+								}
+								var option1992 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1992 = witTypes.None[string]()
+								case 1:
+									value1991 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1992 = witTypes.Some[string](value1991)
+								default:
+									panic("unreachable")
+								}
+
+								option1993 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1988, option1990, option1992})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyF64Type(option1993)
+
+						case 12:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result2006 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value1994 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1996 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option1996 = witTypes.None[string]()
+								case 1:
+									value1995 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option1996 = witTypes.Some[string](value1995)
+								default:
+									panic("unreachable")
+								}
+								result1998 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value1997 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1998 = append(result1998, value1997)
+								}
+
+								result2000 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value1999 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2000 = append(result2000, value1999)
+								}
+
+								var option2002 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option2002 = witTypes.None[string]()
+								case 1:
+									value2001 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option2002 = witTypes.Some[string](value2001)
+								default:
+									panic("unreachable")
+								}
+								var option2005 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option2005 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant2004 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant2004 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant2004 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant2004 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value2003 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant2004 = golem_core_types.MakeRoleOther(value2003)
+
+									default:
+										panic("unreachable")
+									}
+
+									option2005 = witTypes.Some[golem_core_types.Role](variant2004)
+								default:
+									panic("unreachable")
+								}
+
+								result2006 = append(result2006, golem_core_types.NamedFieldType{value1994, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1996, result1998, result2000, option2002, option2005}})
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyRecordType(result2006)
+
+						case 15:
+							result2020 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value2007 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option2008 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option2008 = witTypes.None[int32]()
+								case 1:
+
+									option2008 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option2010 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option2010 = witTypes.None[string]()
+								case 1:
+									value2009 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option2010 = witTypes.Some[string](value2009)
+								default:
+									panic("unreachable")
+								}
+								result2012 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value2011 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2012 = append(result2012, value2011)
+								}
+
+								result2014 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value2013 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2014 = append(result2014, value2013)
+								}
+
+								var option2016 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option2016 = witTypes.None[string]()
+								case 1:
+									value2015 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option2016 = witTypes.Some[string](value2015)
+								default:
+									panic("unreachable")
+								}
+								var option2019 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option2019 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant2018 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant2018 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant2018 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant2018 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value2017 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant2018 = golem_core_types.MakeRoleOther(value2017)
+
+									default:
+										panic("unreachable")
+									}
+
+									option2019 = witTypes.Some[golem_core_types.Role](variant2018)
+								default:
+									panic("unreachable")
+								}
+
+								result2020 = append(result2020, golem_core_types.VariantCaseType{value2007, option2008, golem_core_types.MetadataEnvelope{option2010, result2012, result2014, option2016, option2019}})
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyVariantType(result2020)
+
+						case 16:
+							result2022 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value2021 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2022 = append(result2022, value2021)
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyEnumType(result2022)
+
+						case 17:
+							result2024 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value2023 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2024 = append(result2024, value2023)
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyFlagsType(result2024)
+
+						case 18:
+							result2025 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2025 = append(result2025, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyTupleType(result2025)
+
+						case 19:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option2026 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2026 = witTypes.None[int32]()
+							case 1:
+
+								option2026 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option2027 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2027 = witTypes.None[int32]()
+							case 1:
+
+								option2027 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option2026, option2027})
+
+						case 24:
+							var option2030 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2030 = witTypes.None[[]string]()
+							case 1:
+								result2029 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value2028 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2029 = append(result2029, value2028)
+								}
+
+								option2030 = witTypes.Some[[]string](result2029)
+							default:
+								panic("unreachable")
+							}
+							var option2031 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option2031 = witTypes.None[uint32]()
+							case 1:
+
+								option2031 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option2032 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option2032 = witTypes.None[uint32]()
+							case 1:
+
+								option2032 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option2034 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option2034 = witTypes.None[string]()
+							case 1:
+								value2033 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option2034 = witTypes.Some[string](value2033)
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option2030, option2031, option2032, option2034})
+
+						case 25:
+							var option2037 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2037 = witTypes.None[[]string]()
+							case 1:
+								result2036 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value2035 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2036 = append(result2036, value2035)
+								}
+
+								option2037 = witTypes.Some[[]string](result2036)
+							default:
+								panic("unreachable")
+							}
+							var option2038 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option2038 = witTypes.None[uint32]()
+							case 1:
+
+								option2038 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option2039 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option2039 = witTypes.None[uint32]()
+							case 1:
+
+								option2039 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option2037, option2038, option2039})
+
+						case 26:
+							var option2042 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option2042 = witTypes.None[[]string]()
+							case 1:
+								result2041 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value2040 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2041 = append(result2041, value2040)
+								}
+
+								option2042 = witTypes.Some[[]string](result2041)
+							default:
+								panic("unreachable")
+							}
+							var option2045 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option2045 = witTypes.None[[]string]()
+							case 1:
+								result2044 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value2043 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2044 = append(result2044, value2043)
+								}
+
+								option2045 = witTypes.Some[[]string](result2044)
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option2042, option2045})
+
+						case 27:
+							var option2048 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2048 = witTypes.None[[]string]()
+							case 1:
+								result2047 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value2046 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2047 = append(result2047, value2046)
+								}
+
+								option2048 = witTypes.Some[[]string](result2047)
+							default:
+								panic("unreachable")
+							}
+							var option2051 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option2051 = witTypes.None[[]string]()
+							case 1:
+								result2050 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value2049 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2050 = append(result2050, value2049)
+								}
+
+								option2051 = witTypes.Some[[]string](result2050)
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option2048, option2051})
+
+						case 28:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value2052 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result2054 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value2053 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2054 = append(result2054, value2053)
+							}
+
+							var option2056 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option2056 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value2055 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option2056 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value2055})
+							default:
+								panic("unreachable")
+							}
+							var option2058 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option2058 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value2057 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option2058 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value2057})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value2052, result2054, option2056, option2058})
+
+						case 31:
+							result2080 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value2059 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant2068 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value2060 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2068 = golem_core_types.MakeDiscriminatorRulePrefix(value2060)
+
+								case 1:
+									value2061 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2068 = golem_core_types.MakeDiscriminatorRuleSuffix(value2061)
+
+								case 2:
+									value2062 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2068 = golem_core_types.MakeDiscriminatorRuleContains(value2062)
+
+								case 3:
+									value2063 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2068 = golem_core_types.MakeDiscriminatorRuleRegex(value2063)
+
+								case 4:
+									value2064 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option2066 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option2066 = witTypes.None[string]()
+									case 1:
+										value2065 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option2066 = witTypes.Some[string](value2065)
+									default:
+										panic("unreachable")
+									}
+
+									variant2068 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value2064, option2066})
+
+								case 5:
+									value2067 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2068 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value2067)
+
+								default:
+									panic("unreachable")
+								}
+								var option2070 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option2070 = witTypes.None[string]()
+								case 1:
+									value2069 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option2070 = witTypes.Some[string](value2069)
+								default:
+									panic("unreachable")
+								}
+								result2072 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value2071 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2072 = append(result2072, value2071)
+								}
+
+								result2074 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value2073 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2074 = append(result2074, value2073)
+								}
+
+								var option2076 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option2076 = witTypes.None[string]()
+								case 1:
+									value2075 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option2076 = witTypes.Some[string](value2075)
+								default:
+									panic("unreachable")
+								}
+								var option2079 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option2079 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant2078 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant2078 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant2078 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant2078 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value2077 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant2078 = golem_core_types.MakeRoleOther(value2077)
+
+									default:
+										panic("unreachable")
+									}
+
+									option2079 = witTypes.Some[golem_core_types.Role](variant2078)
+								default:
+									panic("unreachable")
+								}
+
+								result2080 = append(result2080, golem_core_types.UnionBranch{value2059, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant2068, golem_core_types.MetadataEnvelope{option2070, result2072, result2074, option2076, option2079}})
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result2080})
+
+						case 32:
+							var option2082 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option2082 = witTypes.None[string]()
+							case 1:
+								value2081 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option2082 = witTypes.Some[string](value2081)
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option2082})
+
+						case 33:
+							var option2084 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2084 = witTypes.None[string]()
+							case 1:
+								value2083 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option2084 = witTypes.Some[string](value2083)
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option2084})
+
+						case 34:
+							var option2085 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2085 = witTypes.None[int32]()
+							case 1:
+
+								option2085 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyFutureType(option2085)
+
+						case 35:
+							var option2086 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2086 = witTypes.None[int32]()
+							case 1:
+
+								option2086 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyStreamType(option2086)
+
+						default:
+							panic("unreachable")
+						}
+						var option2089 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option2089 = witTypes.None[string]()
+						case 1:
+							value2088 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option2089 = witTypes.Some[string](value2088)
+						default:
+							panic("unreachable")
+						}
+						result2091 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value2090 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2091 = append(result2091, value2090)
+						}
+
+						result2093 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value2092 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2093 = append(result2093, value2092)
+						}
+
+						var option2095 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option2095 = witTypes.None[string]()
+						case 1:
+							value2094 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option2095 = witTypes.Some[string](value2094)
+						default:
+							panic("unreachable")
+						}
+						var option2098 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option2098 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant2097 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant2097 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant2097 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant2097 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value2096 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant2097 = golem_core_types.MakeRoleOther(value2096)
+
+							default:
+								panic("unreachable")
+							}
+
+							option2098 = witTypes.Some[golem_core_types.Role](variant2097)
+						default:
+							panic("unreachable")
+						}
+
+						result2099 = append(result2099, golem_core_types.SchemaTypeNode{variant2087, golem_core_types.MetadataEnvelope{option2089, result2091, result2093, option2095, option2098}})
+					}
+
+					result2103 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))))), index*(6*4))
+						value2100 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option2102 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option2102 = witTypes.None[string]()
+						case 1:
+							value2101 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option2102 = witTypes.Some[string](value2101)
+						default:
+							panic("unreachable")
+						}
+
+						result2103 = append(result2103, golem_core_types.SchemaTypeDef{value2100, option2102, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result2127 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4))))), index*(16+4*4))
+						var variant2126 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value2104 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeStringValue(value2104)
+
+						case 13:
+							result2105 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2105 = append(result2105, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeRecordValue(result2105)
+
+						case 14:
+							var option2106 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option2106 = witTypes.None[int32]()
+							case 1:
+
+								option2106 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option2106})
+
+						case 15:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result2107 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result2107 = append(result2107, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeFlagsValue(result2107)
+
+						case 17:
+							result2108 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2108 = append(result2108, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeTupleValue(result2108)
+
+						case 18:
+							result2109 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2109 = append(result2109, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeListValue(result2109)
+
+						case 19:
+							result2110 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2110 = append(result2110, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeFixedListValue(result2110)
+
+						case 20:
+							result2111 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result2111 = append(result2111, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeMapValue(result2111)
+
+						case 21:
+							var option2112 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2112 = witTypes.None[int32]()
+							case 1:
+
+								option2112 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeOptionValue(option2112)
+
+						case 22:
+							var variant2115 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option2113 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option2113 = witTypes.None[int32]()
+								case 1:
+
+									option2113 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant2115 = golem_core_types.MakeResultValuePayloadOkValue(option2113)
+
+							case 1:
+								var option2114 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option2114 = witTypes.None[int32]()
+								case 1:
+
+									option2114 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant2115 = golem_core_types.MakeResultValuePayloadErrValue(option2114)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeResultValue(variant2115)
+
+						case 23:
+							value2116 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option2118 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option2118 = witTypes.None[string]()
+							case 1:
+								value2117 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option2118 = witTypes.Some[string](value2117)
+							default:
+								panic("unreachable")
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value2116, option2118})
+
+						case 24:
+							value2119 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option2121 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option2121 = witTypes.None[string]()
+							case 1:
+								value2120 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option2121 = witTypes.Some[string](value2120)
+							default:
+								panic("unreachable")
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value2119, option2121})
+
+						case 25:
+							value2122 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2126 = golem_core_types.MakeSchemaValueNodePathValue(value2122)
+
+						case 26:
+							value2123 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeUrlValue(value2123)
+
+						case 27:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value2124 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2124})
+
+						case 30:
+							value2125 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value2125, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result2127 = append(result2127, variant2126)
+					}
+
+					value2128 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4))))
+					result2130 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 15*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 14*4))))), index*(2*4))
+						value2129 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result2130 = append(result2130, value2129)
+					}
+
+					result2142 := make([][]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 17*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 17*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 16*4))))), index*(2*4))
+						result2141 := make([]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*(56+6*4))
+							var variant2140 SpanData
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value2131 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var option2133 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) {
+								case 0:
+
+									option2133 = witTypes.None[string]()
+								case 1:
+									value2132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+									option2133 = witTypes.Some[string](value2132)
+								default:
+									panic("unreachable")
+								}
+								var option2134 witTypes.Option[uint64]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) {
+								case 0:
+
+									option2134 = witTypes.None[uint64]()
+								case 1:
+
+									option2134 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))))
+								default:
+									panic("unreachable")
+								}
+								result2138 := make([]golem_api_context.Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))), index*(5*4))
+									value2135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+									var variant2137 golem_api_context.AttributeValue
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+									case 0:
+										value2136 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+										variant2137 = golem_api_context.MakeAttributeValueString(value2136)
+
+									default:
+										panic("unreachable")
+									}
+
+									result2138 = append(result2138, golem_api_context.Attribute{value2135, variant2137})
+								}
+
+								variant2140 = MakeSpanDataLocalSpan(LocalSpanData{value2131, wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))}, option2133, option2134, result2138, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)})
+
+							case 1:
+								value2139 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant2140 = MakeSpanDataExternalSpan(ExternalSpanData{value2139})
+
+							default:
+								panic("unreachable")
+							}
+
+							result2141 = append(result2141, variant2140)
+						}
+
+						result2142 = append(result2142, result2141)
+					}
+
+					variant2146 = MakeAgentInvocationAgentMethodInvocation(AgentMethodInvocationParameters{value1922, value1923, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result2099, result2103, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}, golem_core_types.SchemaValueTree{result2127, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4)))}}, value2128, result2130, result2142})
+
+				case 2:
+
+					variant2146 = MakeAgentInvocationSaveSnapshot()
+
+				case 3:
+					value2143 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+					value2144 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+
+					variant2146 = MakeAgentInvocationLoadSnapshot(LoadSnapshotParameters{SnapshotData{value2143, value2144}})
+
+				case 4:
+					value2145 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+
+					variant2146 = MakeAgentInvocationProcessOplogEntries(ProcessOplogEntriesParameters{value2145})
+
+				case 5:
+
+					variant2146 = MakeAgentInvocationManualUpdate(ManualUpdateParameters{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))})
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryPendingAgentInvocation(PendingAgentInvocationParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, variant2146})
+
+			case 15:
+				var variant2149 UpdateDescription
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+				case 0:
+
+					variant2149 = MakeUpdateDescriptionAutoUpdate()
+
+				case 1:
+					value2147 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))
+					value2148 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))
+
+					variant2149 = MakeUpdateDescriptionSnapshotBased(golem_api_host.Snapshot{value2147, value2148})
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryPendingUpdate(PendingUpdateParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), variant2149})
+
+			case 16:
+				result2155 := make([]PluginInstallationDescription, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)))), index*(24+6*4))
+					value2150 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+					value2151 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))))
+					result2154 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 5*4))))), index*(4*4))
+						value2152 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						value2153 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+						result2154 = append(result2154, witTypes.Tuple2[string, string]{value2152, value2153})
+					}
+
+					result2155 = append(result2155, PluginInstallationDescription{EnvironmentPluginGrantId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2150, value2151, result2154})
+				}
+
+				variant2471 = MakePublicOplogEntrySuccessfulUpdate(SuccessfulUpdateParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), result2155})
+
+			case 17:
+				var option2157 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+				case 0:
+
+					option2157 = witTypes.None[string]()
+				case 1:
+					value2156 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))
+
+					option2157 = witTypes.Some[string](value2156)
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryFailedUpdate(FailedUpdateParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), option2157})
+
+			case 18:
+
+				variant2471 = MakePublicOplogEntryGrowMemory(GrowMemoryParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24)))})
+
+			case 19:
+
+				variant2471 = MakePublicOplogEntryFilesystemStorageUsageUpdate(FilesystemStorageUsageUpdateParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, *(*int64)(unsafe.Add(unsafe.Pointer(base), 24))})
+
+			case 20:
+				value2158 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+				value2159 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+
+				variant2471 = MakePublicOplogEntryCreateResource(CreateResourceParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), value2158, value2159})
+
+			case 21:
+				value2160 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+				value2161 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+
+				variant2471 = MakePublicOplogEntryDropResource(DropResourceParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), value2160, value2161})
+
+			case 22:
+				value2162 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4))))
+				value2163 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+				variant2471 = MakePublicOplogEntryLog(LogParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24)))), value2162, value2163})
+
+			case 23:
+
+				variant2471 = MakePublicOplogEntryRestart(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}})
+
+			case 24:
+				value2164 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))))
+				value2165 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))
+				result2168 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4))))), index*(4*4))
+					value2166 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value2167 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result2168 = append(result2168, witTypes.Tuple2[string, string]{value2166, value2167})
+				}
+
+				variant2471 = MakePublicOplogEntryActivatePlugin(ActivatePluginParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, PluginInstallationDescription{EnvironmentPluginGrantId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 40)), value2164, value2165, result2168}})
+
+			case 25:
+				value2169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))))
+				value2170 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))
+				result2173 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4))))), index*(4*4))
+					value2171 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value2172 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result2173 = append(result2173, witTypes.Tuple2[string, string]{value2171, value2172})
+				}
+
+				variant2471 = MakePublicOplogEntryDeactivatePlugin(DeactivatePluginParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, PluginInstallationDescription{EnvironmentPluginGrantId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 40)), value2169, value2170, result2173}})
+
+			case 26:
+
+				variant2471 = MakePublicOplogEntryRevert(RevertParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, OplogRegion{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}})
+
+			case 27:
+				value2174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+
+				variant2471 = MakePublicOplogEntryCancelPendingInvocation(CancelPendingInvocationParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, value2174})
+
+			case 28:
+				value2175 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+				var option2177 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) {
+				case 0:
+
+					option2177 = witTypes.None[string]()
+				case 1:
+					value2176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+					option2177 = witTypes.Some[string](value2176)
+				default:
+					panic("unreachable")
+				}
+				var option2179 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) {
+				case 0:
+
+					option2179 = witTypes.None[string]()
+				case 1:
+					value2178 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 7*4))))
+
+					option2179 = witTypes.Some[string](value2178)
+				default:
+					panic("unreachable")
+				}
+				result2183 := make([]golem_api_context.Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 9*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 9*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 8*4))))), index*(5*4))
+					value2180 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var variant2182 golem_api_context.AttributeValue
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+						value2181 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+						variant2182 = golem_api_context.MakeAttributeValueString(value2181)
+
+					default:
+						panic("unreachable")
+					}
+
+					result2183 = append(result2183, golem_api_context.Attribute{value2180, variant2182})
+				}
+
+				variant2471 = MakePublicOplogEntryStartSpan(StartSpanParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, value2175, option2177, option2179, result2183})
+
+			case 29:
+				value2184 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+
+				variant2471 = MakePublicOplogEntryFinishSpan(FinishSpanParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, value2184})
+
+			case 30:
+				value2185 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+				value2186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))))
+				var variant2188 golem_api_context.AttributeValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) {
+				case 0:
+					value2187 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+					variant2188 = golem_api_context.MakeAttributeValueString(value2187)
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntrySetSpanAttribute(SetSpanAttributeParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, value2185, value2186, variant2188})
+
+			case 31:
+				var variant2189 golem_api_host.PersistenceLevel
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+				case 0:
+
+					variant2189 = golem_api_host.MakePersistenceLevelPersistNothing()
+
+				case 1:
+
+					variant2189 = golem_api_host.MakePersistenceLevelPersistRemoteSideEffects()
+
+				case 2:
+
+					variant2189 = golem_api_host.MakePersistenceLevelSmart()
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryChangePersistenceLevel(ChangePersistenceLevelParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, variant2189})
+
+			case 32:
+				value2190 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+
+				variant2471 = MakePublicOplogEntryBeginRemoteTransaction(BeginRemoteTransactionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, value2190})
+
+			case 33:
+
+				variant2471 = MakePublicOplogEntryPreCommitRemoteTransaction(RemoteTransactionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24)))})
+
+			case 34:
+
+				variant2471 = MakePublicOplogEntryPreRollbackRemoteTransaction(RemoteTransactionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24)))})
+
+			case 35:
+
+				variant2471 = MakePublicOplogEntryCommittedRemoteTransaction(RemoteTransactionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24)))})
+
+			case 36:
+
+				variant2471 = MakePublicOplogEntryRolledBackRemoteTransaction(RemoteTransactionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24)))})
+
+			case 37:
+				value2191 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+				value2192 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))))
+
+				variant2471 = MakePublicOplogEntrySnapshot(SnapshotParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, SnapshotData{value2191, value2192}})
+
+			case 38:
+				value2193 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))))
+				value2194 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))
+				result2197 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4))))), index*(4*4))
+					value2195 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value2196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result2197 = append(result2197, witTypes.Tuple2[string, string]{value2195, value2196})
+				}
+
+				value2198 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 6*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 7*4))))
+
+				variant2471 = MakePublicOplogEntryOplogProcessorCheckpoint(OplogProcessorCheckpointParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, PluginInstallationDescription{EnvironmentPluginGrantId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 40)), value2193, value2194, result2197}, golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (56 + 6*4))))}}, value2198}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 8*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (72 + 8*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (80 + 8*4))))})
+
+			case 39:
+				value2199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+				result2230 := make([]golem_api_retry.PredicateNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))))), index*(16+4*4))
+					var variant2229 golem_api_retry.PredicateNode
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+						value2200 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2202 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2202 = golem_api_retry.MakePredicateValueText(value2201)
+
+						case 1:
+
+							variant2202 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2202 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2229 = golem_api_retry.MakePredicateNodePropEq(golem_api_retry.PropertyComparison{value2200, variant2202})
+
+					case 1:
+						value2203 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2205 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2204 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2205 = golem_api_retry.MakePredicateValueText(value2204)
+
+						case 1:
+
+							variant2205 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2205 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2229 = golem_api_retry.MakePredicateNodePropNeq(golem_api_retry.PropertyComparison{value2203, variant2205})
+
+					case 2:
+						value2206 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2208 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2207 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2208 = golem_api_retry.MakePredicateValueText(value2207)
+
+						case 1:
+
+							variant2208 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2208 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2229 = golem_api_retry.MakePredicateNodePropGt(golem_api_retry.PropertyComparison{value2206, variant2208})
+
+					case 3:
+						value2209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2211 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2210 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2211 = golem_api_retry.MakePredicateValueText(value2210)
+
+						case 1:
+
+							variant2211 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2211 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2229 = golem_api_retry.MakePredicateNodePropGte(golem_api_retry.PropertyComparison{value2209, variant2211})
+
+					case 4:
+						value2212 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2214 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2213 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2214 = golem_api_retry.MakePredicateValueText(value2213)
+
+						case 1:
+
+							variant2214 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2214 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2229 = golem_api_retry.MakePredicateNodePropLt(golem_api_retry.PropertyComparison{value2212, variant2214})
+
+					case 5:
+						value2215 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2217 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2216 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2217 = golem_api_retry.MakePredicateValueText(value2216)
+
+						case 1:
+
+							variant2217 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2217 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2229 = golem_api_retry.MakePredicateNodePropLte(golem_api_retry.PropertyComparison{value2215, variant2217})
+
+					case 6:
+						value2218 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant2229 = golem_api_retry.MakePredicateNodePropExists(value2218)
+
+					case 7:
+						value2219 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						result2222 := make([]golem_api_retry.PredicateValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(8+2*4))
+							var variant2221 golem_api_retry.PredicateValue
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value2220 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant2221 = golem_api_retry.MakePredicateValueText(value2220)
+
+							case 1:
+
+								variant2221 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+							case 2:
+
+								variant2221 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+							default:
+								panic("unreachable")
+							}
+
+							result2222 = append(result2222, variant2221)
+						}
+
+						variant2229 = golem_api_retry.MakePredicateNodePropIn(golem_api_retry.PropertySetCheck{value2219, result2222})
+
+					case 8:
+						value2223 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value2224 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant2229 = golem_api_retry.MakePredicateNodePropMatches(golem_api_retry.PropertyPattern{value2223, value2224})
+
+					case 9:
+						value2225 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value2226 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant2229 = golem_api_retry.MakePredicateNodePropStartsWith(golem_api_retry.PropertyPattern{value2225, value2226})
+
+					case 10:
+						value2227 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value2228 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant2229 = golem_api_retry.MakePredicateNodePropContains(golem_api_retry.PropertyPattern{value2227, value2228})
+
+					case 11:
+
+						variant2229 = golem_api_retry.MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 12:
+
+						variant2229 = golem_api_retry.MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 13:
+
+						variant2229 = golem_api_retry.MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 14:
+
+						variant2229 = golem_api_retry.MakePredicateNodePredTrue()
+
+					case 15:
+
+						variant2229 = golem_api_retry.MakePredicateNodePredFalse()
+
+					default:
+						panic("unreachable")
+					}
+
+					result2230 = append(result2230, variant2229)
+				}
+
+				result2263 := make([]golem_api_retry.PolicyNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))), index*32)
+					var variant2262 golem_api_retry.PolicyNode
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant2262 = golem_api_retry.MakePolicyNodePeriodic(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 1:
+
+						variant2262 = golem_api_retry.MakePolicyNodeExponential(golem_api_retry.ExponentialConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*float64)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+					case 2:
+
+						variant2262 = golem_api_retry.MakePolicyNodeFibonacci(golem_api_retry.FibonacciConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+					case 3:
+
+						variant2262 = golem_api_retry.MakePolicyNodeImmediate()
+
+					case 4:
+
+						variant2262 = golem_api_retry.MakePolicyNodeNever()
+
+					case 5:
+
+						variant2262 = golem_api_retry.MakePolicyNodeCountBox(golem_api_retry.CountBoxConfig{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 6:
+
+						variant2262 = golem_api_retry.MakePolicyNodeTimeBox(golem_api_retry.TimeBoxConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+					case 7:
+
+						variant2262 = golem_api_retry.MakePolicyNodeClampDelay(golem_api_retry.ClampConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 24))})
+
+					case 8:
+
+						variant2262 = golem_api_retry.MakePolicyNodeAddDelay(golem_api_retry.AddDelayConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+					case 9:
+
+						variant2262 = golem_api_retry.MakePolicyNodeJitter(golem_api_retry.JitterConfig{*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+					case 10:
+						result2261 := make([]golem_api_retry.PredicateNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(16+4*4))
+							var variant2260 golem_api_retry.PredicateNode
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value2231 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2233 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2232 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2233 = golem_api_retry.MakePredicateValueText(value2232)
+
+								case 1:
+
+									variant2233 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2233 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2260 = golem_api_retry.MakePredicateNodePropEq(golem_api_retry.PropertyComparison{value2231, variant2233})
+
+							case 1:
+								value2234 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2236 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2235 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2236 = golem_api_retry.MakePredicateValueText(value2235)
+
+								case 1:
+
+									variant2236 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2236 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2260 = golem_api_retry.MakePredicateNodePropNeq(golem_api_retry.PropertyComparison{value2234, variant2236})
+
+							case 2:
+								value2237 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2239 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2238 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2239 = golem_api_retry.MakePredicateValueText(value2238)
+
+								case 1:
+
+									variant2239 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2239 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2260 = golem_api_retry.MakePredicateNodePropGt(golem_api_retry.PropertyComparison{value2237, variant2239})
+
+							case 3:
+								value2240 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2242 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2241 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2242 = golem_api_retry.MakePredicateValueText(value2241)
+
+								case 1:
+
+									variant2242 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2242 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2260 = golem_api_retry.MakePredicateNodePropGte(golem_api_retry.PropertyComparison{value2240, variant2242})
+
+							case 4:
+								value2243 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2245 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2244 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2245 = golem_api_retry.MakePredicateValueText(value2244)
+
+								case 1:
+
+									variant2245 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2245 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2260 = golem_api_retry.MakePredicateNodePropLt(golem_api_retry.PropertyComparison{value2243, variant2245})
+
+							case 5:
+								value2246 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2248 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2247 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2248 = golem_api_retry.MakePredicateValueText(value2247)
+
+								case 1:
+
+									variant2248 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2248 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2260 = golem_api_retry.MakePredicateNodePropLte(golem_api_retry.PropertyComparison{value2246, variant2248})
+
+							case 6:
+								value2249 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant2260 = golem_api_retry.MakePredicateNodePropExists(value2249)
+
+							case 7:
+								value2250 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								result2253 := make([]golem_api_retry.PredicateValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(8+2*4))
+									var variant2252 golem_api_retry.PredicateValue
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+									case 0:
+										value2251 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+										variant2252 = golem_api_retry.MakePredicateValueText(value2251)
+
+									case 1:
+
+										variant2252 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+									case 2:
+
+										variant2252 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+									default:
+										panic("unreachable")
+									}
+
+									result2253 = append(result2253, variant2252)
+								}
+
+								variant2260 = golem_api_retry.MakePredicateNodePropIn(golem_api_retry.PropertySetCheck{value2250, result2253})
+
+							case 8:
+								value2254 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								value2255 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								variant2260 = golem_api_retry.MakePredicateNodePropMatches(golem_api_retry.PropertyPattern{value2254, value2255})
+
+							case 9:
+								value2256 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								value2257 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								variant2260 = golem_api_retry.MakePredicateNodePropStartsWith(golem_api_retry.PropertyPattern{value2256, value2257})
+
+							case 10:
+								value2258 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								value2259 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								variant2260 = golem_api_retry.MakePredicateNodePropContains(golem_api_retry.PropertyPattern{value2258, value2259})
+
+							case 11:
+
+								variant2260 = golem_api_retry.MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+							case 12:
+
+								variant2260 = golem_api_retry.MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+							case 13:
+
+								variant2260 = golem_api_retry.MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+							case 14:
+
+								variant2260 = golem_api_retry.MakePredicateNodePredTrue()
+
+							case 15:
+
+								variant2260 = golem_api_retry.MakePredicateNodePredFalse()
+
+							default:
+								panic("unreachable")
+							}
+
+							result2261 = append(result2261, variant2260)
+						}
+
+						variant2262 = golem_api_retry.MakePolicyNodeFilteredOn(golem_api_retry.FilteredConfig{golem_api_retry.RetryPredicate{result2261}, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+					case 11:
+
+						variant2262 = golem_api_retry.MakePolicyNodeAndThen(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 12:
+
+						variant2262 = golem_api_retry.MakePolicyNodePolicyUnion(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 13:
+
+						variant2262 = golem_api_retry.MakePolicyNodePolicyIntersect(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					default:
+						panic("unreachable")
+					}
+
+					result2263 = append(result2263, variant2262)
+				}
+
+				variant2471 = MakePublicOplogEntrySetRetryPolicy(SetRetryPolicyParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, golem_api_retry.NamedRetryPolicy{value2199, uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))), golem_api_retry.RetryPredicate{result2230}, golem_api_retry.RetryPolicy{result2263}}})
+
+			case 40:
+				value2264 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4))))
+
+				variant2471 = MakePublicOplogEntryRemoveRetryPolicy(RemoveRetryPolicyParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, value2264})
+
+			case 41:
+				var variant2265 QueuedCardEvent
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+				case 0:
+
+					variant2265 = MakeQueuedCardEventInstall(QueuedCardEventInstall{golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}}})
+
+				case 1:
+
+					variant2265 = MakeQueuedCardEventRevoke(QueuedCardEventRevoke{golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}}})
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryCardEventQueued(CardEventQueuedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, variant2265})
+
+			case 42:
+				var option2266 witTypes.Option[uint64]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+				case 0:
+
+					option2266 = witTypes.None[uint64]()
+				case 1:
+
+					option2266 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryCardInstalled(CardInstalledParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, option2266, golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 48)))}}})
+
+			case 43:
+
+				variant2471 = MakePublicOplogEntryCardInstallFailed(CardInstallFailedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}}, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))))})
+
+			case 44:
+
+				variant2471 = MakePublicOplogEntryCardRevoked(CardRevokedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}}})
+
+			case 45:
+
+				variant2471 = MakePublicOplogEntryCardExpired(CardExpiredParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}}})
+
+			case 46:
+				result2442 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))), index*(56+22*4))
+					var variant2430 golem_core_types.SchemaTypeBody
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 1:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+					case 2:
+						var option2273 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2273 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2268 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2268 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2267 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2267 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2267 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2267 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2268 = witTypes.Some[golem_core_types.NumericBound](variant2267)
+							default:
+								panic("unreachable")
+							}
+							var option2270 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2270 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2269 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2269 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2269 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2269 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2270 = witTypes.Some[golem_core_types.NumericBound](variant2269)
+							default:
+								panic("unreachable")
+							}
+							var option2272 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2272 = witTypes.None[string]()
+							case 1:
+								value2271 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2272 = witTypes.Some[string](value2271)
+							default:
+								panic("unreachable")
+							}
+
+							option2273 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2268, option2270, option2272})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyS8Type(option2273)
+
+					case 3:
+						var option2280 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2280 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2275 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2275 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2274 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2274 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2274 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2274 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2275 = witTypes.Some[golem_core_types.NumericBound](variant2274)
+							default:
+								panic("unreachable")
+							}
+							var option2277 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2277 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2276 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2276 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2276 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2276 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2277 = witTypes.Some[golem_core_types.NumericBound](variant2276)
+							default:
+								panic("unreachable")
+							}
+							var option2279 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2279 = witTypes.None[string]()
+							case 1:
+								value2278 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2279 = witTypes.Some[string](value2278)
+							default:
+								panic("unreachable")
+							}
+
+							option2280 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2275, option2277, option2279})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyS16Type(option2280)
+
+					case 4:
+						var option2287 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2287 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2282 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2282 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2281 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2281 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2281 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2281 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2282 = witTypes.Some[golem_core_types.NumericBound](variant2281)
+							default:
+								panic("unreachable")
+							}
+							var option2284 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2284 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2283 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2283 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2283 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2283 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2284 = witTypes.Some[golem_core_types.NumericBound](variant2283)
+							default:
+								panic("unreachable")
+							}
+							var option2286 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2286 = witTypes.None[string]()
+							case 1:
+								value2285 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2286 = witTypes.Some[string](value2285)
+							default:
+								panic("unreachable")
+							}
+
+							option2287 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2282, option2284, option2286})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyS32Type(option2287)
+
+					case 5:
+						var option2294 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2294 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2289 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2289 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2288 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2288 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2288 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2288 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2289 = witTypes.Some[golem_core_types.NumericBound](variant2288)
+							default:
+								panic("unreachable")
+							}
+							var option2291 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2291 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2290 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2290 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2290 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2290 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2291 = witTypes.Some[golem_core_types.NumericBound](variant2290)
+							default:
+								panic("unreachable")
+							}
+							var option2293 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2293 = witTypes.None[string]()
+							case 1:
+								value2292 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2293 = witTypes.Some[string](value2292)
+							default:
+								panic("unreachable")
+							}
+
+							option2294 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2289, option2291, option2293})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyS64Type(option2294)
+
+					case 6:
+						var option2301 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2301 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2296 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2296 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2295 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2295 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2295 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2295 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2296 = witTypes.Some[golem_core_types.NumericBound](variant2295)
+							default:
+								panic("unreachable")
+							}
+							var option2298 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2298 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2297 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2297 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2297 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2297 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2298 = witTypes.Some[golem_core_types.NumericBound](variant2297)
+							default:
+								panic("unreachable")
+							}
+							var option2300 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2300 = witTypes.None[string]()
+							case 1:
+								value2299 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2300 = witTypes.Some[string](value2299)
+							default:
+								panic("unreachable")
+							}
+
+							option2301 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2296, option2298, option2300})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyU8Type(option2301)
+
+					case 7:
+						var option2308 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2308 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2303 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2303 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2302 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2302 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2302 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2302 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2303 = witTypes.Some[golem_core_types.NumericBound](variant2302)
+							default:
+								panic("unreachable")
+							}
+							var option2305 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2305 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2304 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2304 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2304 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2304 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2305 = witTypes.Some[golem_core_types.NumericBound](variant2304)
+							default:
+								panic("unreachable")
+							}
+							var option2307 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2307 = witTypes.None[string]()
+							case 1:
+								value2306 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2307 = witTypes.Some[string](value2306)
+							default:
+								panic("unreachable")
+							}
+
+							option2308 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2303, option2305, option2307})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyU16Type(option2308)
+
+					case 8:
+						var option2315 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2315 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2310 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2310 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2309 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2309 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2309 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2309 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2310 = witTypes.Some[golem_core_types.NumericBound](variant2309)
+							default:
+								panic("unreachable")
+							}
+							var option2312 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2312 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2311 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2311 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2311 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2311 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2312 = witTypes.Some[golem_core_types.NumericBound](variant2311)
+							default:
+								panic("unreachable")
+							}
+							var option2314 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2314 = witTypes.None[string]()
+							case 1:
+								value2313 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2314 = witTypes.Some[string](value2313)
+							default:
+								panic("unreachable")
+							}
+
+							option2315 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2310, option2312, option2314})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyU32Type(option2315)
+
+					case 9:
+						var option2322 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2322 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2317 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2317 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2316 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2316 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2316 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2316 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2317 = witTypes.Some[golem_core_types.NumericBound](variant2316)
+							default:
+								panic("unreachable")
+							}
+							var option2319 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2319 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2318 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2318 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2318 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2318 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2319 = witTypes.Some[golem_core_types.NumericBound](variant2318)
+							default:
+								panic("unreachable")
+							}
+							var option2321 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2321 = witTypes.None[string]()
+							case 1:
+								value2320 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2321 = witTypes.Some[string](value2320)
+							default:
+								panic("unreachable")
+							}
+
+							option2322 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2317, option2319, option2321})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyU64Type(option2322)
+
+					case 10:
+						var option2329 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2329 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2324 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2324 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2323 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2323 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2323 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2323 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2324 = witTypes.Some[golem_core_types.NumericBound](variant2323)
+							default:
+								panic("unreachable")
+							}
+							var option2326 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2326 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2325 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2325 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2325 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2325 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2326 = witTypes.Some[golem_core_types.NumericBound](variant2325)
+							default:
+								panic("unreachable")
+							}
+							var option2328 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2328 = witTypes.None[string]()
+							case 1:
+								value2327 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2328 = witTypes.Some[string](value2327)
+							default:
+								panic("unreachable")
+							}
+
+							option2329 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2324, option2326, option2328})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyF32Type(option2329)
+
+					case 11:
+						var option2336 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2336 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2331 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2331 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2330 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2330 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2330 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2330 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2331 = witTypes.Some[golem_core_types.NumericBound](variant2330)
+							default:
+								panic("unreachable")
+							}
+							var option2333 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2333 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2332 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2332 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2332 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2332 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2333 = witTypes.Some[golem_core_types.NumericBound](variant2332)
+							default:
+								panic("unreachable")
+							}
+							var option2335 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2335 = witTypes.None[string]()
+							case 1:
+								value2334 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2335 = witTypes.Some[string](value2334)
+							default:
+								panic("unreachable")
+							}
+
+							option2336 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2331, option2333, option2335})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyF64Type(option2336)
+
+					case 12:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+					case 13:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+					case 14:
+						result2349 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+							value2337 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var option2339 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+							case 0:
+
+								option2339 = witTypes.None[string]()
+							case 1:
+								value2338 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								option2339 = witTypes.Some[string](value2338)
+							default:
+								panic("unreachable")
+							}
+							result2341 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+								value2340 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2341 = append(result2341, value2340)
+							}
+
+							result2343 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+								value2342 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2343 = append(result2343, value2342)
+							}
+
+							var option2345 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+							case 0:
+
+								option2345 = witTypes.None[string]()
+							case 1:
+								value2344 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+								option2345 = witTypes.Some[string](value2344)
+							default:
+								panic("unreachable")
+							}
+							var option2348 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+							case 0:
+
+								option2348 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant2347 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+								case 0:
+
+									variant2347 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant2347 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant2347 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value2346 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+									variant2347 = golem_core_types.MakeRoleOther(value2346)
+
+								default:
+									panic("unreachable")
+								}
+
+								option2348 = witTypes.Some[golem_core_types.Role](variant2347)
+							default:
+								panic("unreachable")
+							}
+
+							result2349 = append(result2349, golem_core_types.NamedFieldType{value2337, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option2339, result2341, result2343, option2345, option2348}})
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyRecordType(result2349)
+
+					case 15:
+						result2363 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+							value2350 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var option2351 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+							case 0:
+
+								option2351 = witTypes.None[int32]()
+							case 1:
+
+								option2351 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+							default:
+								panic("unreachable")
+							}
+							var option2353 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option2353 = witTypes.None[string]()
+							case 1:
+								value2352 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option2353 = witTypes.Some[string](value2352)
+							default:
+								panic("unreachable")
+							}
+							result2355 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+								value2354 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2355 = append(result2355, value2354)
+							}
+
+							result2357 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+								value2356 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2357 = append(result2357, value2356)
+							}
+
+							var option2359 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+							case 0:
+
+								option2359 = witTypes.None[string]()
+							case 1:
+								value2358 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+								option2359 = witTypes.Some[string](value2358)
+							default:
+								panic("unreachable")
+							}
+							var option2362 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+							case 0:
+
+								option2362 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant2361 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+								case 0:
+
+									variant2361 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant2361 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant2361 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value2360 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+									variant2361 = golem_core_types.MakeRoleOther(value2360)
+
+								default:
+									panic("unreachable")
+								}
+
+								option2362 = witTypes.Some[golem_core_types.Role](variant2361)
+							default:
+								panic("unreachable")
+							}
+
+							result2363 = append(result2363, golem_core_types.VariantCaseType{value2350, option2351, golem_core_types.MetadataEnvelope{option2353, result2355, result2357, option2359, option2362}})
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyVariantType(result2363)
+
+					case 16:
+						result2365 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+							value2364 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2365 = append(result2365, value2364)
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyEnumType(result2365)
+
+					case 17:
+						result2367 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+							value2366 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2367 = append(result2367, value2366)
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyFlagsType(result2367)
+
+					case 18:
+						result2368 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result2368 = append(result2368, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyTupleType(result2368)
+
+					case 19:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 20:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+					case 21:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 22:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 23:
+						var option2369 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2369 = witTypes.None[int32]()
+						case 1:
+
+							option2369 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+						var option2370 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option2370 = witTypes.None[int32]()
+						case 1:
+
+							option2370 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option2369, option2370})
+
+					case 24:
+						var option2373 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2373 = witTypes.None[[]string]()
+						case 1:
+							result2372 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value2371 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2372 = append(result2372, value2371)
+							}
+
+							option2373 = witTypes.Some[[]string](result2372)
+						default:
+							panic("unreachable")
+						}
+						var option2374 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option2374 = witTypes.None[uint32]()
+						case 1:
+
+							option2374 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option2375 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+						case 0:
+
+							option2375 = witTypes.None[uint32]()
+						case 1:
+
+							option2375 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option2377 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+						case 0:
+
+							option2377 = witTypes.None[string]()
+						case 1:
+							value2376 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+							option2377 = witTypes.Some[string](value2376)
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option2373, option2374, option2375, option2377})
+
+					case 25:
+						var option2380 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2380 = witTypes.None[[]string]()
+						case 1:
+							result2379 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value2378 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2379 = append(result2379, value2378)
+							}
+
+							option2380 = witTypes.Some[[]string](result2379)
+						default:
+							panic("unreachable")
+						}
+						var option2381 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option2381 = witTypes.None[uint32]()
+						case 1:
+
+							option2381 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option2382 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+						case 0:
+
+							option2382 = witTypes.None[uint32]()
+						case 1:
+
+							option2382 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option2380, option2381, option2382})
+
+					case 26:
+						var option2385 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+						case 0:
+
+							option2385 = witTypes.None[[]string]()
+						case 1:
+							result2384 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value2383 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2384 = append(result2384, value2383)
+							}
+
+							option2385 = witTypes.Some[[]string](result2384)
+						default:
+							panic("unreachable")
+						}
+						var option2388 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+						case 0:
+
+							option2388 = witTypes.None[[]string]()
+						case 1:
+							result2387 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+								value2386 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2387 = append(result2387, value2386)
+							}
+
+							option2388 = witTypes.Some[[]string](result2387)
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option2385, option2388})
+
+					case 27:
+						var option2391 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2391 = witTypes.None[[]string]()
+						case 1:
+							result2390 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value2389 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2390 = append(result2390, value2389)
+							}
+
+							option2391 = witTypes.Some[[]string](result2390)
+						default:
+							panic("unreachable")
+						}
+						var option2394 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option2394 = witTypes.None[[]string]()
+						case 1:
+							result2393 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+								value2392 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2393 = append(result2393, value2392)
+							}
+
+							option2394 = witTypes.Some[[]string](result2393)
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option2391, option2394})
+
+					case 28:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+					case 29:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+					case 30:
+						value2395 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						result2397 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+							value2396 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2397 = append(result2397, value2396)
+						}
+
+						var option2399 witTypes.Option[golem_core_types.QuantityValue]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+						case 0:
+
+							option2399 = witTypes.None[golem_core_types.QuantityValue]()
+						case 1:
+							value2398 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+							option2399 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value2398})
+						default:
+							panic("unreachable")
+						}
+						var option2401 witTypes.Option[golem_core_types.QuantityValue]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+						case 0:
+
+							option2401 = witTypes.None[golem_core_types.QuantityValue]()
+						case 1:
+							value2400 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+							option2401 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value2400})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value2395, result2397, option2399, option2401})
+
+					case 31:
+						result2423 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+							value2402 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var variant2411 golem_core_types.DiscriminatorRule
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+							case 0:
+								value2403 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant2411 = golem_core_types.MakeDiscriminatorRulePrefix(value2403)
+
+							case 1:
+								value2404 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant2411 = golem_core_types.MakeDiscriminatorRuleSuffix(value2404)
+
+							case 2:
+								value2405 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant2411 = golem_core_types.MakeDiscriminatorRuleContains(value2405)
+
+							case 3:
+								value2406 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant2411 = golem_core_types.MakeDiscriminatorRuleRegex(value2406)
+
+							case 4:
+								value2407 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+								var option2409 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+								case 0:
+
+									option2409 = witTypes.None[string]()
+								case 1:
+									value2408 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+									option2409 = witTypes.Some[string](value2408)
+								default:
+									panic("unreachable")
+								}
+
+								variant2411 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value2407, option2409})
+
+							case 5:
+								value2410 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant2411 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value2410)
+
+							default:
+								panic("unreachable")
+							}
+							var option2413 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+							case 0:
+
+								option2413 = witTypes.None[string]()
+							case 1:
+								value2412 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+								option2413 = witTypes.Some[string](value2412)
+							default:
+								panic("unreachable")
+							}
+							result2415 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+								value2414 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2415 = append(result2415, value2414)
+							}
+
+							result2417 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+								value2416 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2417 = append(result2417, value2416)
+							}
+
+							var option2419 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+							case 0:
+
+								option2419 = witTypes.None[string]()
+							case 1:
+								value2418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+								option2419 = witTypes.Some[string](value2418)
+							default:
+								panic("unreachable")
+							}
+							var option2422 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+							case 0:
+
+								option2422 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant2421 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+								case 0:
+
+									variant2421 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant2421 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant2421 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value2420 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+									variant2421 = golem_core_types.MakeRoleOther(value2420)
+
+								default:
+									panic("unreachable")
+								}
+
+								option2422 = witTypes.Some[golem_core_types.Role](variant2421)
+							default:
+								panic("unreachable")
+							}
+
+							result2423 = append(result2423, golem_core_types.UnionBranch{value2402, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant2411, golem_core_types.MetadataEnvelope{option2413, result2415, result2417, option2419, option2422}})
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result2423})
+
+					case 32:
+						var option2425 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+						case 0:
+
+							option2425 = witTypes.None[string]()
+						case 1:
+							value2424 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+							option2425 = witTypes.Some[string](value2424)
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option2425})
+
+					case 33:
+						var option2427 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2427 = witTypes.None[string]()
+						case 1:
+							value2426 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+							option2427 = witTypes.Some[string](value2426)
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option2427})
+
+					case 34:
+						var option2428 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2428 = witTypes.None[int32]()
+						case 1:
+
+							option2428 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyFutureType(option2428)
+
+					case 35:
+						var option2429 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2429 = witTypes.None[int32]()
+						case 1:
+
+							option2429 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyStreamType(option2429)
+
+					default:
+						panic("unreachable")
+					}
+					var option2432 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+					case 0:
+
+						option2432 = witTypes.None[string]()
+					case 1:
+						value2431 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+						option2432 = witTypes.Some[string](value2431)
+					default:
+						panic("unreachable")
+					}
+					result2434 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+						value2433 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result2434 = append(result2434, value2433)
+					}
+
+					result2436 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+						value2435 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result2436 = append(result2436, value2435)
+					}
+
+					var option2438 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+					case 0:
+
+						option2438 = witTypes.None[string]()
+					case 1:
+						value2437 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+						option2438 = witTypes.Some[string](value2437)
+					default:
+						panic("unreachable")
+					}
+					var option2441 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+					case 0:
+
+						option2441 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant2440 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+						case 0:
+
+							variant2440 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant2440 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant2440 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value2439 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+							variant2440 = golem_core_types.MakeRoleOther(value2439)
+
+						default:
+							panic("unreachable")
+						}
+
+						option2441 = witTypes.Some[golem_core_types.Role](variant2440)
+					default:
+						panic("unreachable")
+					}
+
+					result2442 = append(result2442, golem_core_types.SchemaTypeNode{variant2430, golem_core_types.MetadataEnvelope{option2432, result2434, result2436, option2438, option2441}})
+				}
+
+				result2446 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))), index*(6*4))
+					value2443 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var option2445 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+
+						option2445 = witTypes.None[string]()
+					case 1:
+						value2444 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+						option2445 = witTypes.Some[string](value2444)
+					default:
+						panic("unreachable")
+					}
+
+					result2446 = append(result2446, golem_core_types.SchemaTypeDef{value2443, option2445, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+				}
+
+				result2470 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))))), index*(16+4*4))
+					var variant2469 golem_core_types.SchemaValueNode
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+					case 1:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 2:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 3:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 4:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 5:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 6:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 7:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 8:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 9:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 10:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 11:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 12:
+						value2447 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeStringValue(value2447)
+
+					case 13:
+						result2448 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result2448 = append(result2448, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeRecordValue(result2448)
+
+					case 14:
+						var option2449 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+						case 0:
+
+							option2449 = witTypes.None[int32]()
+						case 1:
+
+							option2449 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+						default:
+							panic("unreachable")
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option2449})
+
+					case 15:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 16:
+						result2450 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+							result2450 = append(result2450, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeFlagsValue(result2450)
+
+					case 17:
+						result2451 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result2451 = append(result2451, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeTupleValue(result2451)
+
+					case 18:
+						result2452 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result2452 = append(result2452, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeListValue(result2452)
+
+					case 19:
+						result2453 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result2453 = append(result2453, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeFixedListValue(result2453)
+
+					case 20:
+						result2454 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+							result2454 = append(result2454, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeMapValue(result2454)
+
+					case 21:
+						var option2455 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2455 = witTypes.None[int32]()
+						case 1:
+
+							option2455 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeOptionValue(option2455)
+
+					case 22:
+						var variant2458 golem_core_types.ResultValuePayload
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+							var option2456 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option2456 = witTypes.None[int32]()
+							case 1:
+
+								option2456 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2458 = golem_core_types.MakeResultValuePayloadOkValue(option2456)
+
+						case 1:
+							var option2457 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option2457 = witTypes.None[int32]()
+							case 1:
+
+								option2457 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2458 = golem_core_types.MakeResultValuePayloadErrValue(option2457)
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeResultValue(variant2458)
+
+					case 23:
+						value2459 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var option2461 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option2461 = witTypes.None[string]()
+						case 1:
+							value2460 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option2461 = witTypes.Some[string](value2460)
+						default:
+							panic("unreachable")
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value2459, option2461})
+
+					case 24:
+						value2462 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var option2464 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option2464 = witTypes.None[string]()
+						case 1:
+							value2463 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option2464 = witTypes.Some[string](value2463)
+						default:
+							panic("unreachable")
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value2462, option2464})
+
+					case 25:
+						value2465 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant2469 = golem_core_types.MakeSchemaValueNodePathValue(value2465)
+
+					case 26:
+						value2466 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeUrlValue(value2466)
+
+					case 27:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+					case 28:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+					case 29:
+						value2467 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2467})
+
+					case 30:
+						value2468 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value2468, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+					case 31:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+					case 32:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+					default:
+						panic("unreachable")
+					}
+
+					result2470 = append(result2470, variant2469)
+				}
+
+				variant2471 = MakePublicOplogEntryHostStreamFrame(HostStreamFrameParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32)))), golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result2442, result2446, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result2470, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}}})
+
+			case 47:
+
+				variant2471 = MakePublicOplogEntryCompletionDiscarded(CompletionDiscardedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 24)))})
+
+			default:
+				panic("unreachable")
+			}
+
+			result2472 = append(result2472, variant2471)
+		}
+
+		option2473 = witTypes.Some[[]PublicOplogEntry](result2472)
+	default:
+		panic("unreachable")
+	}
+	result2474 := option2473
+	return result2474
+
+}
+
+//go:wasmimport golem:api/oplog@1.5.0 [constructor]search-oplog
+func wasm_import_constructor_search_oplog(arg0 int64, arg1 int64, arg2 uintptr, arg3 uint32, arg4 uintptr, arg5 uint32) int32
+
+func MakeSearchOplog(agentId golem_core_types.AgentId, text string) *SearchOplog {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData((agentId).AgentId))
+	pinner.Pin(utf8)
+	utf80 := unsafe.Pointer(unsafe.StringData(text))
+	pinner.Pin(utf80)
+	result := wasm_import_constructor_search_oplog(int64((((agentId).ComponentId).Uuid).HighBits), int64((((agentId).ComponentId).Uuid).LowBits), uintptr(utf8), uint32(len((agentId).AgentId)), uintptr(utf80), uint32(len(text)))
+	return SearchOplogFromOwnHandle(int32(uintptr(result)))
+
+}
+
+//go:wasmimport golem:api/oplog@1.5.0 [method]search-oplog.get-next
+func wasm_import_method_search_oplog_get_next(arg0 int32, arg1 uintptr)
+
+func (self *SearchOplog) GetNext() witTypes.Option[[]witTypes.Tuple2[uint64, PublicOplogEntry]] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_method_search_oplog_get_next((self).Handle(), returnArea)
+	var option2473 witTypes.Option[[]witTypes.Tuple2[uint64, PublicOplogEntry]]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option2473 = witTypes.None[[]witTypes.Tuple2[uint64, PublicOplogEntry]]()
+	case 1:
+		result2472 := make([]witTypes.Tuple2[uint64, PublicOplogEntry], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(176+10*4))
+			var variant2471 PublicOplogEntry
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+				value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 1*4))))
+				result := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 3*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 3*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))), index*(4*4))
+					value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result = append(result, witTypes.Tuple2[string, string]{value0, value1})
+				}
+
+				var option witTypes.Option[golem_core_types.AgentId]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (96 + 4*4)))) {
+				case 0:
+
+					option = witTypes.None[golem_core_types.AgentId]()
+				case 1:
+					value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (120 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (120 + 5*4))))
+
+					option = witTypes.Some[golem_core_types.AgentId](golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (104 + 4*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (112 + 4*4))))}}, value2})
+				default:
+					panic("unreachable")
+				}
+				result8 := make([]PluginInstallationDescription, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (136 + 7*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (136 + 7*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (136 + 6*4))))), index*(24+6*4))
+					value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+					value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))))
+					result7 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 5*4))))), index*(4*4))
+						value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+						result7 = append(result7, witTypes.Tuple2[string, string]{value5, value6})
+					}
+
+					result8 = append(result8, PluginInstallationDescription{EnvironmentPluginGrantId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value3, value4, result7})
+				}
+
+				result214 := make([]LocalAgentConfigEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (136 + 9*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (136 + 9*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (136 + 8*4))))), index*(10*4))
+					result10 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*(2*4))
+						value9 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result10 = append(result10, value9)
+					}
+
+					result185 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))), index*(56+22*4))
+						var variant173 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option16 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option16 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option11 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option11 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option11 = witTypes.Some[golem_core_types.NumericBound](variant)
+								default:
+									panic("unreachable")
+								}
+								var option13 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option13 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant12 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant12 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant12 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant12 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option13 = witTypes.Some[golem_core_types.NumericBound](variant12)
+								default:
+									panic("unreachable")
+								}
+								var option15 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option15 = witTypes.None[string]()
+								case 1:
+									value14 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option15 = witTypes.Some[string](value14)
+								default:
+									panic("unreachable")
+								}
+
+								option16 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option11, option13, option15})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyS8Type(option16)
+
+						case 3:
+							var option23 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option23 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option18 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option18 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant17 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant17 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant17 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant17 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option18 = witTypes.Some[golem_core_types.NumericBound](variant17)
+								default:
+									panic("unreachable")
+								}
+								var option20 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option20 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant19 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant19 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant19 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant19 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option20 = witTypes.Some[golem_core_types.NumericBound](variant19)
+								default:
+									panic("unreachable")
+								}
+								var option22 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option22 = witTypes.None[string]()
+								case 1:
+									value21 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option22 = witTypes.Some[string](value21)
+								default:
+									panic("unreachable")
+								}
+
+								option23 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option18, option20, option22})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyS16Type(option23)
+
+						case 4:
+							var option30 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option30 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option25 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option25 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant24 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant24 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant24 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant24 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option25 = witTypes.Some[golem_core_types.NumericBound](variant24)
+								default:
+									panic("unreachable")
+								}
+								var option27 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option27 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant26 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant26 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant26 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant26 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option27 = witTypes.Some[golem_core_types.NumericBound](variant26)
+								default:
+									panic("unreachable")
+								}
+								var option29 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option29 = witTypes.None[string]()
+								case 1:
+									value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option29 = witTypes.Some[string](value28)
+								default:
+									panic("unreachable")
+								}
+
+								option30 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option25, option27, option29})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyS32Type(option30)
+
+						case 5:
+							var option37 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option37 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option32 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option32 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant31 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant31 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant31 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant31 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option32 = witTypes.Some[golem_core_types.NumericBound](variant31)
+								default:
+									panic("unreachable")
+								}
+								var option34 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option34 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant33 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant33 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant33 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant33 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option34 = witTypes.Some[golem_core_types.NumericBound](variant33)
+								default:
+									panic("unreachable")
+								}
+								var option36 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option36 = witTypes.None[string]()
+								case 1:
+									value35 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option36 = witTypes.Some[string](value35)
+								default:
+									panic("unreachable")
+								}
+
+								option37 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option32, option34, option36})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyS64Type(option37)
+
+						case 6:
+							var option44 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option44 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option39 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option39 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant38 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant38 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant38 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant38 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option39 = witTypes.Some[golem_core_types.NumericBound](variant38)
+								default:
+									panic("unreachable")
+								}
+								var option41 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option41 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant40 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant40 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant40 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant40 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option41 = witTypes.Some[golem_core_types.NumericBound](variant40)
+								default:
+									panic("unreachable")
+								}
+								var option43 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option43 = witTypes.None[string]()
+								case 1:
+									value42 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option43 = witTypes.Some[string](value42)
+								default:
+									panic("unreachable")
+								}
+
+								option44 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option39, option41, option43})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyU8Type(option44)
+
+						case 7:
+							var option51 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option51 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option46 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option46 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant45 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant45 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant45 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant45 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option46 = witTypes.Some[golem_core_types.NumericBound](variant45)
+								default:
+									panic("unreachable")
+								}
+								var option48 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option48 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant47 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant47 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant47 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant47 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option48 = witTypes.Some[golem_core_types.NumericBound](variant47)
+								default:
+									panic("unreachable")
+								}
+								var option50 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option50 = witTypes.None[string]()
+								case 1:
+									value49 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option50 = witTypes.Some[string](value49)
+								default:
+									panic("unreachable")
+								}
+
+								option51 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option46, option48, option50})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyU16Type(option51)
+
+						case 8:
+							var option58 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option58 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option53 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option53 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant52 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant52 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant52 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant52 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option53 = witTypes.Some[golem_core_types.NumericBound](variant52)
+								default:
+									panic("unreachable")
+								}
+								var option55 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option55 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant54 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant54 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant54 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant54 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option55 = witTypes.Some[golem_core_types.NumericBound](variant54)
+								default:
+									panic("unreachable")
+								}
+								var option57 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option57 = witTypes.None[string]()
+								case 1:
+									value56 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option57 = witTypes.Some[string](value56)
+								default:
+									panic("unreachable")
+								}
+
+								option58 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option53, option55, option57})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyU32Type(option58)
+
+						case 9:
+							var option65 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option65 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option60 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option60 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant59 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant59 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant59 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant59 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option60 = witTypes.Some[golem_core_types.NumericBound](variant59)
+								default:
+									panic("unreachable")
+								}
+								var option62 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option62 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant61 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant61 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant61 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant61 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option62 = witTypes.Some[golem_core_types.NumericBound](variant61)
+								default:
+									panic("unreachable")
+								}
+								var option64 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option64 = witTypes.None[string]()
+								case 1:
+									value63 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option64 = witTypes.Some[string](value63)
+								default:
+									panic("unreachable")
+								}
+
+								option65 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option60, option62, option64})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyU64Type(option65)
+
+						case 10:
+							var option72 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option72 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option67 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option67 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant66 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant66 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant66 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant66 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option67 = witTypes.Some[golem_core_types.NumericBound](variant66)
+								default:
+									panic("unreachable")
+								}
+								var option69 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option69 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant68 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant68 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant68 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant68 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option69 = witTypes.Some[golem_core_types.NumericBound](variant68)
+								default:
+									panic("unreachable")
+								}
+								var option71 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option71 = witTypes.None[string]()
+								case 1:
+									value70 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option71 = witTypes.Some[string](value70)
+								default:
+									panic("unreachable")
+								}
+
+								option72 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option67, option69, option71})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyF32Type(option72)
+
+						case 11:
+							var option79 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option79 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option74 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option74 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant73 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant73 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant73 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant73 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option74 = witTypes.Some[golem_core_types.NumericBound](variant73)
+								default:
+									panic("unreachable")
+								}
+								var option76 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option76 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant75 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant75 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant75 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant75 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option76 = witTypes.Some[golem_core_types.NumericBound](variant75)
+								default:
+									panic("unreachable")
+								}
+								var option78 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option78 = witTypes.None[string]()
+								case 1:
+									value77 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option78 = witTypes.Some[string](value77)
+								default:
+									panic("unreachable")
+								}
+
+								option79 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option74, option76, option78})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyF64Type(option79)
+
+						case 12:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result92 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value80 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option82 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option82 = witTypes.None[string]()
+								case 1:
+									value81 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option82 = witTypes.Some[string](value81)
+								default:
+									panic("unreachable")
+								}
+								result84 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value83 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result84 = append(result84, value83)
+								}
+
+								result86 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value85 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result86 = append(result86, value85)
+								}
+
+								var option88 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option88 = witTypes.None[string]()
+								case 1:
+									value87 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option88 = witTypes.Some[string](value87)
+								default:
+									panic("unreachable")
+								}
+								var option91 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option91 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant90 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant90 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant90 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant90 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value89 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant90 = golem_core_types.MakeRoleOther(value89)
+
+									default:
+										panic("unreachable")
+									}
+
+									option91 = witTypes.Some[golem_core_types.Role](variant90)
+								default:
+									panic("unreachable")
+								}
+
+								result92 = append(result92, golem_core_types.NamedFieldType{value80, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option82, result84, result86, option88, option91}})
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyRecordType(result92)
+
+						case 15:
+							result106 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value93 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option94 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option94 = witTypes.None[int32]()
+								case 1:
+
+									option94 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option96 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option96 = witTypes.None[string]()
+								case 1:
+									value95 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option96 = witTypes.Some[string](value95)
+								default:
+									panic("unreachable")
+								}
+								result98 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value97 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result98 = append(result98, value97)
+								}
+
+								result100 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value99 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result100 = append(result100, value99)
+								}
+
+								var option102 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option102 = witTypes.None[string]()
+								case 1:
+									value101 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option102 = witTypes.Some[string](value101)
+								default:
+									panic("unreachable")
+								}
+								var option105 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option105 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant104 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant104 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant104 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant104 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value103 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant104 = golem_core_types.MakeRoleOther(value103)
+
+									default:
+										panic("unreachable")
+									}
+
+									option105 = witTypes.Some[golem_core_types.Role](variant104)
+								default:
+									panic("unreachable")
+								}
+
+								result106 = append(result106, golem_core_types.VariantCaseType{value93, option94, golem_core_types.MetadataEnvelope{option96, result98, result100, option102, option105}})
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyVariantType(result106)
+
+						case 16:
+							result108 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value107 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result108 = append(result108, value107)
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyEnumType(result108)
+
+						case 17:
+							result110 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value109 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result110 = append(result110, value109)
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyFlagsType(result110)
+
+						case 18:
+							result111 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result111 = append(result111, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyTupleType(result111)
+
+						case 19:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option112 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option112 = witTypes.None[int32]()
+							case 1:
+
+								option112 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option113 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option113 = witTypes.None[int32]()
+							case 1:
+
+								option113 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option112, option113})
+
+						case 24:
+							var option116 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option116 = witTypes.None[[]string]()
+							case 1:
+								result115 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value114 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result115 = append(result115, value114)
+								}
+
+								option116 = witTypes.Some[[]string](result115)
+							default:
+								panic("unreachable")
+							}
+							var option117 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option117 = witTypes.None[uint32]()
+							case 1:
+
+								option117 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option118 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option118 = witTypes.None[uint32]()
+							case 1:
+
+								option118 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option120 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option120 = witTypes.None[string]()
+							case 1:
+								value119 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option120 = witTypes.Some[string](value119)
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option116, option117, option118, option120})
+
+						case 25:
+							var option123 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option123 = witTypes.None[[]string]()
+							case 1:
+								result122 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value121 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result122 = append(result122, value121)
+								}
+
+								option123 = witTypes.Some[[]string](result122)
+							default:
+								panic("unreachable")
+							}
+							var option124 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option124 = witTypes.None[uint32]()
+							case 1:
+
+								option124 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option125 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option125 = witTypes.None[uint32]()
+							case 1:
+
+								option125 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option123, option124, option125})
+
+						case 26:
+							var option128 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option128 = witTypes.None[[]string]()
+							case 1:
+								result127 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value126 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result127 = append(result127, value126)
+								}
+
+								option128 = witTypes.Some[[]string](result127)
+							default:
+								panic("unreachable")
+							}
+							var option131 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option131 = witTypes.None[[]string]()
+							case 1:
+								result130 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value129 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result130 = append(result130, value129)
+								}
+
+								option131 = witTypes.Some[[]string](result130)
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option128, option131})
+
+						case 27:
+							var option134 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option134 = witTypes.None[[]string]()
+							case 1:
+								result133 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result133 = append(result133, value132)
+								}
+
+								option134 = witTypes.Some[[]string](result133)
+							default:
+								panic("unreachable")
+							}
+							var option137 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option137 = witTypes.None[[]string]()
+							case 1:
+								result136 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result136 = append(result136, value135)
+								}
+
+								option137 = witTypes.Some[[]string](result136)
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option134, option137})
+
+						case 28:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value138 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result140 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value139 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result140 = append(result140, value139)
+							}
+
+							var option142 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option142 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value141 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option142 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value141})
+							default:
+								panic("unreachable")
+							}
+							var option144 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option144 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value143 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option144 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value143})
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value138, result140, option142, option144})
+
+						case 31:
+							result166 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value145 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant154 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant154 = golem_core_types.MakeDiscriminatorRulePrefix(value146)
+
+								case 1:
+									value147 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant154 = golem_core_types.MakeDiscriminatorRuleSuffix(value147)
+
+								case 2:
+									value148 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant154 = golem_core_types.MakeDiscriminatorRuleContains(value148)
+
+								case 3:
+									value149 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant154 = golem_core_types.MakeDiscriminatorRuleRegex(value149)
+
+								case 4:
+									value150 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option152 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option152 = witTypes.None[string]()
+									case 1:
+										value151 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option152 = witTypes.Some[string](value151)
+									default:
+										panic("unreachable")
+									}
+
+									variant154 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value150, option152})
+
+								case 5:
+									value153 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant154 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value153)
+
+								default:
+									panic("unreachable")
+								}
+								var option156 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option156 = witTypes.None[string]()
+								case 1:
+									value155 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option156 = witTypes.Some[string](value155)
+								default:
+									panic("unreachable")
+								}
+								result158 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value157 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result158 = append(result158, value157)
+								}
+
+								result160 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value159 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result160 = append(result160, value159)
+								}
+
+								var option162 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option162 = witTypes.None[string]()
+								case 1:
+									value161 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option162 = witTypes.Some[string](value161)
+								default:
+									panic("unreachable")
+								}
+								var option165 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option165 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant164 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant164 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant164 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant164 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value163 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant164 = golem_core_types.MakeRoleOther(value163)
+
+									default:
+										panic("unreachable")
+									}
+
+									option165 = witTypes.Some[golem_core_types.Role](variant164)
+								default:
+									panic("unreachable")
+								}
+
+								result166 = append(result166, golem_core_types.UnionBranch{value145, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant154, golem_core_types.MetadataEnvelope{option156, result158, result160, option162, option165}})
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result166})
+
+						case 32:
+							var option168 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option168 = witTypes.None[string]()
+							case 1:
+								value167 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option168 = witTypes.Some[string](value167)
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option168})
+
+						case 33:
+							var option170 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option170 = witTypes.None[string]()
+							case 1:
+								value169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option170 = witTypes.Some[string](value169)
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option170})
+
+						case 34:
+							var option171 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option171 = witTypes.None[int32]()
+							case 1:
+
+								option171 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyFutureType(option171)
+
+						case 35:
+							var option172 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option172 = witTypes.None[int32]()
+							case 1:
+
+								option172 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant173 = golem_core_types.MakeSchemaTypeBodyStreamType(option172)
+
+						default:
+							panic("unreachable")
+						}
+						var option175 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option175 = witTypes.None[string]()
+						case 1:
+							value174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option175 = witTypes.Some[string](value174)
+						default:
+							panic("unreachable")
+						}
+						result177 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result177 = append(result177, value176)
+						}
+
+						result179 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value178 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result179 = append(result179, value178)
+						}
+
+						var option181 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option181 = witTypes.None[string]()
+						case 1:
+							value180 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option181 = witTypes.Some[string](value180)
+						default:
+							panic("unreachable")
+						}
+						var option184 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option184 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant183 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant183 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant183 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant183 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value182 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant183 = golem_core_types.MakeRoleOther(value182)
+
+							default:
+								panic("unreachable")
+							}
+
+							option184 = witTypes.Some[golem_core_types.Role](variant183)
+						default:
+							panic("unreachable")
+						}
+
+						result185 = append(result185, golem_core_types.SchemaTypeNode{variant173, golem_core_types.MetadataEnvelope{option175, result177, result179, option181, option184}})
+					}
+
+					result189 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))), index*(6*4))
+						value186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option188 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option188 = witTypes.None[string]()
+						case 1:
+							value187 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option188 = witTypes.Some[string](value187)
+						default:
+							panic("unreachable")
+						}
+
+						result189 = append(result189, golem_core_types.SchemaTypeDef{value186, option188, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result213 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))), index*(16+4*4))
+						var variant212 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value190 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant212 = golem_core_types.MakeSchemaValueNodeStringValue(value190)
+
+						case 13:
+							result191 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result191 = append(result191, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeRecordValue(result191)
+
+						case 14:
+							var option192 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option192 = witTypes.None[int32]()
+							case 1:
+
+								option192 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option192})
+
+						case 15:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result193 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result193 = append(result193, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeFlagsValue(result193)
+
+						case 17:
+							result194 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result194 = append(result194, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeTupleValue(result194)
+
+						case 18:
+							result195 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result195 = append(result195, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeListValue(result195)
+
+						case 19:
+							result196 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result196 = append(result196, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeFixedListValue(result196)
+
+						case 20:
+							result197 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result197 = append(result197, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeMapValue(result197)
+
+						case 21:
+							var option198 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option198 = witTypes.None[int32]()
+							case 1:
+
+								option198 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeOptionValue(option198)
+
+						case 22:
+							var variant201 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option199 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option199 = witTypes.None[int32]()
+								case 1:
+
+									option199 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant201 = golem_core_types.MakeResultValuePayloadOkValue(option199)
+
+							case 1:
+								var option200 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option200 = witTypes.None[int32]()
+								case 1:
+
+									option200 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant201 = golem_core_types.MakeResultValuePayloadErrValue(option200)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeResultValue(variant201)
+
+						case 23:
+							value202 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option204 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option204 = witTypes.None[string]()
+							case 1:
+								value203 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option204 = witTypes.Some[string](value203)
+							default:
+								panic("unreachable")
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value202, option204})
+
+						case 24:
+							value205 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option207 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option207 = witTypes.None[string]()
+							case 1:
+								value206 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option207 = witTypes.Some[string](value206)
+							default:
+								panic("unreachable")
+							}
+
+							variant212 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value205, option207})
+
+						case 25:
+							value208 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant212 = golem_core_types.MakeSchemaValueNodePathValue(value208)
+
+						case 26:
+							value209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant212 = golem_core_types.MakeSchemaValueNodeUrlValue(value209)
+
+						case 27:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value210 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant212 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value210})
+
+						case 30:
+							value211 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant212 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value211, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant212 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result213 = append(result213, variant212)
+					}
+
+					result214 = append(result214, LocalAgentConfigEntry{result10, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result185, result189, *(*int32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))}, golem_core_types.SchemaValueTree{result213, *(*int32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))}}})
+				}
+
+				var option215 witTypes.Option[golem_core_types.Uuid]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (136 + 10*4)))) {
+				case 0:
+
+					option215 = witTypes.None[golem_core_types.Uuid]()
+				case 1:
+
+					option215 = witTypes.Some[golem_core_types.Uuid](golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (144 + 10*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (152 + 10*4))))})
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryCreate(CreateParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}}, value}, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4))))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4)))), result, golem_core_types.AccountId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 4*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (72 + 4*4))))}}, golem_api_host.EnvironmentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (80 + 4*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (88 + 4*4))))}}, option, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (120 + 6*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (128 + 6*4)))), result8, result214, option215, golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (160 + 10*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (168 + 10*4))))}})
+
+			case 1:
+				var option216 witTypes.Option[uint64]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+				case 0:
+
+					option216 = witTypes.None[uint64]()
+				case 1:
+
+					option216 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40))))
+				default:
+					panic("unreachable")
+				}
+				value217 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 1*4))))
+				var option422 witTypes.Option[golem_core_types.TypedSchemaValue]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4)))) {
+				case 0:
+
+					option422 = witTypes.None[golem_core_types.TypedSchemaValue]()
+				case 1:
+					result393 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 3*4))))), index*(56+22*4))
+						var variant381 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option224 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option224 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option219 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option219 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant218 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant218 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant218 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant218 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option219 = witTypes.Some[golem_core_types.NumericBound](variant218)
+								default:
+									panic("unreachable")
+								}
+								var option221 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option221 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant220 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant220 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant220 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant220 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option221 = witTypes.Some[golem_core_types.NumericBound](variant220)
+								default:
+									panic("unreachable")
+								}
+								var option223 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option223 = witTypes.None[string]()
+								case 1:
+									value222 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option223 = witTypes.Some[string](value222)
+								default:
+									panic("unreachable")
+								}
+
+								option224 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option219, option221, option223})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyS8Type(option224)
+
+						case 3:
+							var option231 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option231 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option226 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option226 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant225 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant225 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant225 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant225 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option226 = witTypes.Some[golem_core_types.NumericBound](variant225)
+								default:
+									panic("unreachable")
+								}
+								var option228 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option228 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant227 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant227 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant227 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant227 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option228 = witTypes.Some[golem_core_types.NumericBound](variant227)
+								default:
+									panic("unreachable")
+								}
+								var option230 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option230 = witTypes.None[string]()
+								case 1:
+									value229 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option230 = witTypes.Some[string](value229)
+								default:
+									panic("unreachable")
+								}
+
+								option231 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option226, option228, option230})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyS16Type(option231)
+
+						case 4:
+							var option238 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option238 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option233 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option233 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant232 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant232 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant232 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant232 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option233 = witTypes.Some[golem_core_types.NumericBound](variant232)
+								default:
+									panic("unreachable")
+								}
+								var option235 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option235 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant234 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant234 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant234 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant234 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option235 = witTypes.Some[golem_core_types.NumericBound](variant234)
+								default:
+									panic("unreachable")
+								}
+								var option237 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option237 = witTypes.None[string]()
+								case 1:
+									value236 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option237 = witTypes.Some[string](value236)
+								default:
+									panic("unreachable")
+								}
+
+								option238 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option233, option235, option237})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyS32Type(option238)
+
+						case 5:
+							var option245 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option245 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option240 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option240 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant239 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant239 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant239 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant239 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option240 = witTypes.Some[golem_core_types.NumericBound](variant239)
+								default:
+									panic("unreachable")
+								}
+								var option242 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option242 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant241 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant241 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant241 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant241 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option242 = witTypes.Some[golem_core_types.NumericBound](variant241)
+								default:
+									panic("unreachable")
+								}
+								var option244 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option244 = witTypes.None[string]()
+								case 1:
+									value243 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option244 = witTypes.Some[string](value243)
+								default:
+									panic("unreachable")
+								}
+
+								option245 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option240, option242, option244})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyS64Type(option245)
+
+						case 6:
+							var option252 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option252 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option247 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option247 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant246 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant246 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant246 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant246 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option247 = witTypes.Some[golem_core_types.NumericBound](variant246)
+								default:
+									panic("unreachable")
+								}
+								var option249 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option249 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant248 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant248 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant248 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant248 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option249 = witTypes.Some[golem_core_types.NumericBound](variant248)
+								default:
+									panic("unreachable")
+								}
+								var option251 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option251 = witTypes.None[string]()
+								case 1:
+									value250 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option251 = witTypes.Some[string](value250)
+								default:
+									panic("unreachable")
+								}
+
+								option252 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option247, option249, option251})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyU8Type(option252)
+
+						case 7:
+							var option259 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option259 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option254 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option254 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant253 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant253 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant253 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant253 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option254 = witTypes.Some[golem_core_types.NumericBound](variant253)
+								default:
+									panic("unreachable")
+								}
+								var option256 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option256 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant255 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant255 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant255 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant255 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option256 = witTypes.Some[golem_core_types.NumericBound](variant255)
+								default:
+									panic("unreachable")
+								}
+								var option258 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option258 = witTypes.None[string]()
+								case 1:
+									value257 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option258 = witTypes.Some[string](value257)
+								default:
+									panic("unreachable")
+								}
+
+								option259 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option254, option256, option258})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyU16Type(option259)
+
+						case 8:
+							var option266 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option266 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option261 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option261 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant260 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant260 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant260 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant260 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option261 = witTypes.Some[golem_core_types.NumericBound](variant260)
+								default:
+									panic("unreachable")
+								}
+								var option263 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option263 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant262 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant262 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant262 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant262 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option263 = witTypes.Some[golem_core_types.NumericBound](variant262)
+								default:
+									panic("unreachable")
+								}
+								var option265 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option265 = witTypes.None[string]()
+								case 1:
+									value264 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option265 = witTypes.Some[string](value264)
+								default:
+									panic("unreachable")
+								}
+
+								option266 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option261, option263, option265})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyU32Type(option266)
+
+						case 9:
+							var option273 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option273 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option268 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option268 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant267 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant267 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant267 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant267 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option268 = witTypes.Some[golem_core_types.NumericBound](variant267)
+								default:
+									panic("unreachable")
+								}
+								var option270 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option270 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant269 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant269 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant269 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant269 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option270 = witTypes.Some[golem_core_types.NumericBound](variant269)
+								default:
+									panic("unreachable")
+								}
+								var option272 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option272 = witTypes.None[string]()
+								case 1:
+									value271 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option272 = witTypes.Some[string](value271)
+								default:
+									panic("unreachable")
+								}
+
+								option273 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option268, option270, option272})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyU64Type(option273)
+
+						case 10:
+							var option280 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option280 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option275 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option275 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant274 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant274 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant274 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant274 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option275 = witTypes.Some[golem_core_types.NumericBound](variant274)
+								default:
+									panic("unreachable")
+								}
+								var option277 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option277 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant276 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant276 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant276 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant276 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option277 = witTypes.Some[golem_core_types.NumericBound](variant276)
+								default:
+									panic("unreachable")
+								}
+								var option279 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option279 = witTypes.None[string]()
+								case 1:
+									value278 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option279 = witTypes.Some[string](value278)
+								default:
+									panic("unreachable")
+								}
+
+								option280 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option275, option277, option279})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyF32Type(option280)
+
+						case 11:
+							var option287 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option287 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option282 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option282 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant281 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant281 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant281 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant281 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option282 = witTypes.Some[golem_core_types.NumericBound](variant281)
+								default:
+									panic("unreachable")
+								}
+								var option284 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option284 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant283 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant283 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant283 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant283 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option284 = witTypes.Some[golem_core_types.NumericBound](variant283)
+								default:
+									panic("unreachable")
+								}
+								var option286 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option286 = witTypes.None[string]()
+								case 1:
+									value285 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option286 = witTypes.Some[string](value285)
+								default:
+									panic("unreachable")
+								}
+
+								option287 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option282, option284, option286})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyF64Type(option287)
+
+						case 12:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result300 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value288 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option290 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option290 = witTypes.None[string]()
+								case 1:
+									value289 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option290 = witTypes.Some[string](value289)
+								default:
+									panic("unreachable")
+								}
+								result292 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value291 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result292 = append(result292, value291)
+								}
+
+								result294 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value293 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result294 = append(result294, value293)
+								}
+
+								var option296 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option296 = witTypes.None[string]()
+								case 1:
+									value295 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option296 = witTypes.Some[string](value295)
+								default:
+									panic("unreachable")
+								}
+								var option299 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option299 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant298 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant298 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant298 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant298 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value297 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant298 = golem_core_types.MakeRoleOther(value297)
+
+									default:
+										panic("unreachable")
+									}
+
+									option299 = witTypes.Some[golem_core_types.Role](variant298)
+								default:
+									panic("unreachable")
+								}
+
+								result300 = append(result300, golem_core_types.NamedFieldType{value288, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option290, result292, result294, option296, option299}})
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyRecordType(result300)
+
+						case 15:
+							result314 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value301 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option302 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option302 = witTypes.None[int32]()
+								case 1:
+
+									option302 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option304 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option304 = witTypes.None[string]()
+								case 1:
+									value303 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option304 = witTypes.Some[string](value303)
+								default:
+									panic("unreachable")
+								}
+								result306 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value305 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result306 = append(result306, value305)
+								}
+
+								result308 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value307 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result308 = append(result308, value307)
+								}
+
+								var option310 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option310 = witTypes.None[string]()
+								case 1:
+									value309 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option310 = witTypes.Some[string](value309)
+								default:
+									panic("unreachable")
+								}
+								var option313 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option313 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant312 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant312 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant312 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant312 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value311 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant312 = golem_core_types.MakeRoleOther(value311)
+
+									default:
+										panic("unreachable")
+									}
+
+									option313 = witTypes.Some[golem_core_types.Role](variant312)
+								default:
+									panic("unreachable")
+								}
+
+								result314 = append(result314, golem_core_types.VariantCaseType{value301, option302, golem_core_types.MetadataEnvelope{option304, result306, result308, option310, option313}})
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyVariantType(result314)
+
+						case 16:
+							result316 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value315 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result316 = append(result316, value315)
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyEnumType(result316)
+
+						case 17:
+							result318 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value317 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result318 = append(result318, value317)
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyFlagsType(result318)
+
+						case 18:
+							result319 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result319 = append(result319, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyTupleType(result319)
+
+						case 19:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option320 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option320 = witTypes.None[int32]()
+							case 1:
+
+								option320 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option321 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option321 = witTypes.None[int32]()
+							case 1:
+
+								option321 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option320, option321})
+
+						case 24:
+							var option324 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option324 = witTypes.None[[]string]()
+							case 1:
+								result323 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value322 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result323 = append(result323, value322)
+								}
+
+								option324 = witTypes.Some[[]string](result323)
+							default:
+								panic("unreachable")
+							}
+							var option325 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option325 = witTypes.None[uint32]()
+							case 1:
+
+								option325 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option326 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option326 = witTypes.None[uint32]()
+							case 1:
+
+								option326 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option328 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option328 = witTypes.None[string]()
+							case 1:
+								value327 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option328 = witTypes.Some[string](value327)
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option324, option325, option326, option328})
+
+						case 25:
+							var option331 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option331 = witTypes.None[[]string]()
+							case 1:
+								result330 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value329 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result330 = append(result330, value329)
+								}
+
+								option331 = witTypes.Some[[]string](result330)
+							default:
+								panic("unreachable")
+							}
+							var option332 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option332 = witTypes.None[uint32]()
+							case 1:
+
+								option332 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option333 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option333 = witTypes.None[uint32]()
+							case 1:
+
+								option333 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option331, option332, option333})
+
+						case 26:
+							var option336 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option336 = witTypes.None[[]string]()
+							case 1:
+								result335 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value334 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result335 = append(result335, value334)
+								}
+
+								option336 = witTypes.Some[[]string](result335)
+							default:
+								panic("unreachable")
+							}
+							var option339 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option339 = witTypes.None[[]string]()
+							case 1:
+								result338 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value337 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result338 = append(result338, value337)
+								}
+
+								option339 = witTypes.Some[[]string](result338)
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option336, option339})
+
+						case 27:
+							var option342 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option342 = witTypes.None[[]string]()
+							case 1:
+								result341 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value340 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result341 = append(result341, value340)
+								}
+
+								option342 = witTypes.Some[[]string](result341)
+							default:
+								panic("unreachable")
+							}
+							var option345 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option345 = witTypes.None[[]string]()
+							case 1:
+								result344 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value343 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result344 = append(result344, value343)
+								}
+
+								option345 = witTypes.Some[[]string](result344)
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option342, option345})
+
+						case 28:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value346 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result348 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value347 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result348 = append(result348, value347)
+							}
+
+							var option350 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option350 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value349 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option350 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value349})
+							default:
+								panic("unreachable")
+							}
+							var option352 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option352 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value351 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option352 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value351})
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value346, result348, option350, option352})
+
+						case 31:
+							result374 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant362 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value354 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant362 = golem_core_types.MakeDiscriminatorRulePrefix(value354)
+
+								case 1:
+									value355 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant362 = golem_core_types.MakeDiscriminatorRuleSuffix(value355)
+
+								case 2:
+									value356 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant362 = golem_core_types.MakeDiscriminatorRuleContains(value356)
+
+								case 3:
+									value357 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant362 = golem_core_types.MakeDiscriminatorRuleRegex(value357)
+
+								case 4:
+									value358 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option360 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option360 = witTypes.None[string]()
+									case 1:
+										value359 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option360 = witTypes.Some[string](value359)
+									default:
+										panic("unreachable")
+									}
+
+									variant362 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value358, option360})
+
+								case 5:
+									value361 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant362 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value361)
+
+								default:
+									panic("unreachable")
+								}
+								var option364 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option364 = witTypes.None[string]()
+								case 1:
+									value363 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option364 = witTypes.Some[string](value363)
+								default:
+									panic("unreachable")
+								}
+								result366 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value365 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result366 = append(result366, value365)
+								}
+
+								result368 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value367 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result368 = append(result368, value367)
+								}
+
+								var option370 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option370 = witTypes.None[string]()
+								case 1:
+									value369 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option370 = witTypes.Some[string](value369)
+								default:
+									panic("unreachable")
+								}
+								var option373 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option373 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant372 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant372 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant372 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant372 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value371 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant372 = golem_core_types.MakeRoleOther(value371)
+
+									default:
+										panic("unreachable")
+									}
+
+									option373 = witTypes.Some[golem_core_types.Role](variant372)
+								default:
+									panic("unreachable")
+								}
+
+								result374 = append(result374, golem_core_types.UnionBranch{value353, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant362, golem_core_types.MetadataEnvelope{option364, result366, result368, option370, option373}})
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result374})
+
+						case 32:
+							var option376 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option376 = witTypes.None[string]()
+							case 1:
+								value375 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option376 = witTypes.Some[string](value375)
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option376})
+
+						case 33:
+							var option378 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option378 = witTypes.None[string]()
+							case 1:
+								value377 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option378 = witTypes.Some[string](value377)
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option378})
+
+						case 34:
+							var option379 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option379 = witTypes.None[int32]()
+							case 1:
+
+								option379 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyFutureType(option379)
+
+						case 35:
+							var option380 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option380 = witTypes.None[int32]()
+							case 1:
+
+								option380 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant381 = golem_core_types.MakeSchemaTypeBodyStreamType(option380)
+
+						default:
+							panic("unreachable")
+						}
+						var option383 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option383 = witTypes.None[string]()
+						case 1:
+							value382 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option383 = witTypes.Some[string](value382)
+						default:
+							panic("unreachable")
+						}
+						result385 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value384 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result385 = append(result385, value384)
+						}
+
+						result387 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value386 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result387 = append(result387, value386)
+						}
+
+						var option389 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option389 = witTypes.None[string]()
+						case 1:
+							value388 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option389 = witTypes.Some[string](value388)
+						default:
+							panic("unreachable")
+						}
+						var option392 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option392 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant391 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant391 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant391 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant391 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value390 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant391 = golem_core_types.MakeRoleOther(value390)
+
+							default:
+								panic("unreachable")
+							}
+
+							option392 = witTypes.Some[golem_core_types.Role](variant391)
+						default:
+							panic("unreachable")
+						}
+
+						result393 = append(result393, golem_core_types.SchemaTypeNode{variant381, golem_core_types.MetadataEnvelope{option383, result385, result387, option389, option392}})
+					}
+
+					result397 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))), index*(6*4))
+						value394 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option396 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option396 = witTypes.None[string]()
+						case 1:
+							value395 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option396 = witTypes.Some[string](value395)
+						default:
+							panic("unreachable")
+						}
+
+						result397 = append(result397, golem_core_types.SchemaTypeDef{value394, option396, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result421 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 9*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 9*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))), index*(16+4*4))
+						var variant420 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value398 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant420 = golem_core_types.MakeSchemaValueNodeStringValue(value398)
+
+						case 13:
+							result399 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result399 = append(result399, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeRecordValue(result399)
+
+						case 14:
+							var option400 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option400 = witTypes.None[int32]()
+							case 1:
+
+								option400 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option400})
+
+						case 15:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result401 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result401 = append(result401, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeFlagsValue(result401)
+
+						case 17:
+							result402 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result402 = append(result402, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeTupleValue(result402)
+
+						case 18:
+							result403 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result403 = append(result403, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeListValue(result403)
+
+						case 19:
+							result404 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result404 = append(result404, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeFixedListValue(result404)
+
+						case 20:
+							result405 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result405 = append(result405, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeMapValue(result405)
+
+						case 21:
+							var option406 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option406 = witTypes.None[int32]()
+							case 1:
+
+								option406 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeOptionValue(option406)
+
+						case 22:
+							var variant409 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option407 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option407 = witTypes.None[int32]()
+								case 1:
+
+									option407 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant409 = golem_core_types.MakeResultValuePayloadOkValue(option407)
+
+							case 1:
+								var option408 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option408 = witTypes.None[int32]()
+								case 1:
+
+									option408 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant409 = golem_core_types.MakeResultValuePayloadErrValue(option408)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeResultValue(variant409)
+
+						case 23:
+							value410 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option412 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option412 = witTypes.None[string]()
+							case 1:
+								value411 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option412 = witTypes.Some[string](value411)
+							default:
+								panic("unreachable")
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value410, option412})
+
+						case 24:
+							value413 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option415 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option415 = witTypes.None[string]()
+							case 1:
+								value414 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option415 = witTypes.Some[string](value414)
+							default:
+								panic("unreachable")
+							}
+
+							variant420 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value413, option415})
+
+						case 25:
+							value416 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant420 = golem_core_types.MakeSchemaValueNodePathValue(value416)
+
+						case 26:
+							value417 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant420 = golem_core_types.MakeSchemaValueNodeUrlValue(value417)
+
+						case 27:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant420 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value418})
+
+						case 30:
+							value419 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant420 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value419, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant420 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result421 = append(result421, variant420)
+					}
+
+					option422 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result393, result397, *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))}, golem_core_types.SchemaValueTree{result421, *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 10*4)))}})
+				default:
+					panic("unreachable")
+				}
+				var variant425 WrappedFunctionType
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) {
+				case 0:
+
+					variant425 = MakeWrappedFunctionTypeReadLocal()
+
+				case 1:
+
+					variant425 = MakeWrappedFunctionTypeWriteLocal()
+
+				case 2:
+
+					variant425 = MakeWrappedFunctionTypeReadRemote()
+
+				case 3:
+
+					variant425 = MakeWrappedFunctionTypeWriteRemote()
+
+				case 4:
+					var option423 witTypes.Option[uint64]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 10*4)))) {
+					case 0:
+
+						option423 = witTypes.None[uint64]()
+					case 1:
+
+						option423 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (72 + 10*4)))))
+					default:
+						panic("unreachable")
+					}
+
+					variant425 = MakeWrappedFunctionTypeWriteRemoteBatched(option423)
+
+				case 5:
+					var option424 witTypes.Option[uint64]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 10*4)))) {
+					case 0:
+
+						option424 = witTypes.None[uint64]()
+					case 1:
+
+						option424 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (72 + 10*4)))))
+					default:
+						panic("unreachable")
+					}
+
+					variant425 = MakeWrappedFunctionTypeWriteRemoteTransaction(option424)
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryStart(StartParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, option216, value217, option422, variant425})
+
+			case 2:
+				var option630 witTypes.Option[golem_core_types.TypedSchemaValue]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+				case 0:
+
+					option630 = witTypes.None[golem_core_types.TypedSchemaValue]()
+				case 1:
+					result601 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))), index*(56+22*4))
+						var variant589 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option432 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option432 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option427 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option427 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant426 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant426 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant426 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant426 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option427 = witTypes.Some[golem_core_types.NumericBound](variant426)
+								default:
+									panic("unreachable")
+								}
+								var option429 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option429 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant428 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant428 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant428 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant428 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option429 = witTypes.Some[golem_core_types.NumericBound](variant428)
+								default:
+									panic("unreachable")
+								}
+								var option431 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option431 = witTypes.None[string]()
+								case 1:
+									value430 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option431 = witTypes.Some[string](value430)
+								default:
+									panic("unreachable")
+								}
+
+								option432 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option427, option429, option431})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyS8Type(option432)
+
+						case 3:
+							var option439 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option439 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option434 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option434 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant433 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant433 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant433 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant433 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option434 = witTypes.Some[golem_core_types.NumericBound](variant433)
+								default:
+									panic("unreachable")
+								}
+								var option436 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option436 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant435 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant435 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant435 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant435 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option436 = witTypes.Some[golem_core_types.NumericBound](variant435)
+								default:
+									panic("unreachable")
+								}
+								var option438 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option438 = witTypes.None[string]()
+								case 1:
+									value437 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option438 = witTypes.Some[string](value437)
+								default:
+									panic("unreachable")
+								}
+
+								option439 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option434, option436, option438})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyS16Type(option439)
+
+						case 4:
+							var option446 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option446 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option441 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option441 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant440 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant440 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant440 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant440 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option441 = witTypes.Some[golem_core_types.NumericBound](variant440)
+								default:
+									panic("unreachable")
+								}
+								var option443 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option443 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant442 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant442 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant442 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant442 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option443 = witTypes.Some[golem_core_types.NumericBound](variant442)
+								default:
+									panic("unreachable")
+								}
+								var option445 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option445 = witTypes.None[string]()
+								case 1:
+									value444 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option445 = witTypes.Some[string](value444)
+								default:
+									panic("unreachable")
+								}
+
+								option446 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option441, option443, option445})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyS32Type(option446)
+
+						case 5:
+							var option453 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option453 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option448 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option448 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant447 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant447 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant447 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant447 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option448 = witTypes.Some[golem_core_types.NumericBound](variant447)
+								default:
+									panic("unreachable")
+								}
+								var option450 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option450 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant449 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant449 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant449 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant449 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option450 = witTypes.Some[golem_core_types.NumericBound](variant449)
+								default:
+									panic("unreachable")
+								}
+								var option452 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option452 = witTypes.None[string]()
+								case 1:
+									value451 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option452 = witTypes.Some[string](value451)
+								default:
+									panic("unreachable")
+								}
+
+								option453 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option448, option450, option452})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyS64Type(option453)
+
+						case 6:
+							var option460 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option460 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option455 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option455 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant454 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant454 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant454 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant454 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option455 = witTypes.Some[golem_core_types.NumericBound](variant454)
+								default:
+									panic("unreachable")
+								}
+								var option457 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option457 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant456 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant456 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant456 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant456 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option457 = witTypes.Some[golem_core_types.NumericBound](variant456)
+								default:
+									panic("unreachable")
+								}
+								var option459 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option459 = witTypes.None[string]()
+								case 1:
+									value458 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option459 = witTypes.Some[string](value458)
+								default:
+									panic("unreachable")
+								}
+
+								option460 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option455, option457, option459})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyU8Type(option460)
+
+						case 7:
+							var option467 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option467 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option462 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option462 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant461 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant461 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant461 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant461 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option462 = witTypes.Some[golem_core_types.NumericBound](variant461)
+								default:
+									panic("unreachable")
+								}
+								var option464 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option464 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant463 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant463 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant463 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant463 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option464 = witTypes.Some[golem_core_types.NumericBound](variant463)
+								default:
+									panic("unreachable")
+								}
+								var option466 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option466 = witTypes.None[string]()
+								case 1:
+									value465 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option466 = witTypes.Some[string](value465)
+								default:
+									panic("unreachable")
+								}
+
+								option467 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option462, option464, option466})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyU16Type(option467)
+
+						case 8:
+							var option474 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option474 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option469 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option469 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant468 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant468 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant468 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant468 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option469 = witTypes.Some[golem_core_types.NumericBound](variant468)
+								default:
+									panic("unreachable")
+								}
+								var option471 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option471 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant470 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant470 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant470 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant470 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option471 = witTypes.Some[golem_core_types.NumericBound](variant470)
+								default:
+									panic("unreachable")
+								}
+								var option473 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option473 = witTypes.None[string]()
+								case 1:
+									value472 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option473 = witTypes.Some[string](value472)
+								default:
+									panic("unreachable")
+								}
+
+								option474 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option469, option471, option473})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyU32Type(option474)
+
+						case 9:
+							var option481 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option481 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option476 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option476 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant475 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant475 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant475 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant475 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option476 = witTypes.Some[golem_core_types.NumericBound](variant475)
+								default:
+									panic("unreachable")
+								}
+								var option478 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option478 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant477 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant477 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant477 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant477 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option478 = witTypes.Some[golem_core_types.NumericBound](variant477)
+								default:
+									panic("unreachable")
+								}
+								var option480 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option480 = witTypes.None[string]()
+								case 1:
+									value479 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option480 = witTypes.Some[string](value479)
+								default:
+									panic("unreachable")
+								}
+
+								option481 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option476, option478, option480})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyU64Type(option481)
+
+						case 10:
+							var option488 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option488 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option483 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option483 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant482 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant482 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant482 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant482 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option483 = witTypes.Some[golem_core_types.NumericBound](variant482)
+								default:
+									panic("unreachable")
+								}
+								var option485 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option485 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant484 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant484 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant484 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant484 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option485 = witTypes.Some[golem_core_types.NumericBound](variant484)
+								default:
+									panic("unreachable")
+								}
+								var option487 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option487 = witTypes.None[string]()
+								case 1:
+									value486 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option487 = witTypes.Some[string](value486)
+								default:
+									panic("unreachable")
+								}
+
+								option488 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option483, option485, option487})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyF32Type(option488)
+
+						case 11:
+							var option495 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option495 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option490 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option490 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant489 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant489 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant489 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant489 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option490 = witTypes.Some[golem_core_types.NumericBound](variant489)
+								default:
+									panic("unreachable")
+								}
+								var option492 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option492 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant491 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant491 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant491 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant491 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option492 = witTypes.Some[golem_core_types.NumericBound](variant491)
+								default:
+									panic("unreachable")
+								}
+								var option494 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option494 = witTypes.None[string]()
+								case 1:
+									value493 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option494 = witTypes.Some[string](value493)
+								default:
+									panic("unreachable")
+								}
+
+								option495 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option490, option492, option494})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyF64Type(option495)
+
+						case 12:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result508 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value496 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option498 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option498 = witTypes.None[string]()
+								case 1:
+									value497 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option498 = witTypes.Some[string](value497)
+								default:
+									panic("unreachable")
+								}
+								result500 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value499 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result500 = append(result500, value499)
+								}
+
+								result502 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value501 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result502 = append(result502, value501)
+								}
+
+								var option504 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option504 = witTypes.None[string]()
+								case 1:
+									value503 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option504 = witTypes.Some[string](value503)
+								default:
+									panic("unreachable")
+								}
+								var option507 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option507 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant506 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant506 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant506 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant506 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value505 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant506 = golem_core_types.MakeRoleOther(value505)
+
+									default:
+										panic("unreachable")
+									}
+
+									option507 = witTypes.Some[golem_core_types.Role](variant506)
+								default:
+									panic("unreachable")
+								}
+
+								result508 = append(result508, golem_core_types.NamedFieldType{value496, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option498, result500, result502, option504, option507}})
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyRecordType(result508)
+
+						case 15:
+							result522 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value509 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option510 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option510 = witTypes.None[int32]()
+								case 1:
+
+									option510 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option512 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option512 = witTypes.None[string]()
+								case 1:
+									value511 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option512 = witTypes.Some[string](value511)
+								default:
+									panic("unreachable")
+								}
+								result514 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value513 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result514 = append(result514, value513)
+								}
+
+								result516 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value515 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result516 = append(result516, value515)
+								}
+
+								var option518 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option518 = witTypes.None[string]()
+								case 1:
+									value517 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option518 = witTypes.Some[string](value517)
+								default:
+									panic("unreachable")
+								}
+								var option521 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option521 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant520 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant520 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant520 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant520 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value519 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant520 = golem_core_types.MakeRoleOther(value519)
+
+									default:
+										panic("unreachable")
+									}
+
+									option521 = witTypes.Some[golem_core_types.Role](variant520)
+								default:
+									panic("unreachable")
+								}
+
+								result522 = append(result522, golem_core_types.VariantCaseType{value509, option510, golem_core_types.MetadataEnvelope{option512, result514, result516, option518, option521}})
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyVariantType(result522)
+
+						case 16:
+							result524 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value523 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result524 = append(result524, value523)
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyEnumType(result524)
+
+						case 17:
+							result526 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value525 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result526 = append(result526, value525)
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyFlagsType(result526)
+
+						case 18:
+							result527 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result527 = append(result527, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyTupleType(result527)
+
+						case 19:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option528 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option528 = witTypes.None[int32]()
+							case 1:
+
+								option528 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option529 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option529 = witTypes.None[int32]()
+							case 1:
+
+								option529 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option528, option529})
+
+						case 24:
+							var option532 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option532 = witTypes.None[[]string]()
+							case 1:
+								result531 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value530 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result531 = append(result531, value530)
+								}
+
+								option532 = witTypes.Some[[]string](result531)
+							default:
+								panic("unreachable")
+							}
+							var option533 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option533 = witTypes.None[uint32]()
+							case 1:
+
+								option533 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option534 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option534 = witTypes.None[uint32]()
+							case 1:
+
+								option534 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option536 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option536 = witTypes.None[string]()
+							case 1:
+								value535 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option536 = witTypes.Some[string](value535)
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option532, option533, option534, option536})
+
+						case 25:
+							var option539 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option539 = witTypes.None[[]string]()
+							case 1:
+								result538 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value537 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result538 = append(result538, value537)
+								}
+
+								option539 = witTypes.Some[[]string](result538)
+							default:
+								panic("unreachable")
+							}
+							var option540 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option540 = witTypes.None[uint32]()
+							case 1:
+
+								option540 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option541 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option541 = witTypes.None[uint32]()
+							case 1:
+
+								option541 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option539, option540, option541})
+
+						case 26:
+							var option544 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option544 = witTypes.None[[]string]()
+							case 1:
+								result543 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value542 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result543 = append(result543, value542)
+								}
+
+								option544 = witTypes.Some[[]string](result543)
+							default:
+								panic("unreachable")
+							}
+							var option547 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option547 = witTypes.None[[]string]()
+							case 1:
+								result546 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value545 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result546 = append(result546, value545)
+								}
+
+								option547 = witTypes.Some[[]string](result546)
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option544, option547})
+
+						case 27:
+							var option550 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option550 = witTypes.None[[]string]()
+							case 1:
+								result549 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value548 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result549 = append(result549, value548)
+								}
+
+								option550 = witTypes.Some[[]string](result549)
+							default:
+								panic("unreachable")
+							}
+							var option553 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option553 = witTypes.None[[]string]()
+							case 1:
+								result552 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value551 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result552 = append(result552, value551)
+								}
+
+								option553 = witTypes.Some[[]string](result552)
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option550, option553})
+
+						case 28:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value554 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result556 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value555 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result556 = append(result556, value555)
+							}
+
+							var option558 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option558 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value557 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option558 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value557})
+							default:
+								panic("unreachable")
+							}
+							var option560 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option560 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value559 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option560 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value559})
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value554, result556, option558, option560})
+
+						case 31:
+							result582 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value561 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant570 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value562 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant570 = golem_core_types.MakeDiscriminatorRulePrefix(value562)
+
+								case 1:
+									value563 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant570 = golem_core_types.MakeDiscriminatorRuleSuffix(value563)
+
+								case 2:
+									value564 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant570 = golem_core_types.MakeDiscriminatorRuleContains(value564)
+
+								case 3:
+									value565 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant570 = golem_core_types.MakeDiscriminatorRuleRegex(value565)
+
+								case 4:
+									value566 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option568 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option568 = witTypes.None[string]()
+									case 1:
+										value567 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option568 = witTypes.Some[string](value567)
+									default:
+										panic("unreachable")
+									}
+
+									variant570 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value566, option568})
+
+								case 5:
+									value569 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant570 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value569)
+
+								default:
+									panic("unreachable")
+								}
+								var option572 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option572 = witTypes.None[string]()
+								case 1:
+									value571 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option572 = witTypes.Some[string](value571)
+								default:
+									panic("unreachable")
+								}
+								result574 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value573 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result574 = append(result574, value573)
+								}
+
+								result576 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value575 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result576 = append(result576, value575)
+								}
+
+								var option578 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option578 = witTypes.None[string]()
+								case 1:
+									value577 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option578 = witTypes.Some[string](value577)
+								default:
+									panic("unreachable")
+								}
+								var option581 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option581 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant580 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant580 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant580 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant580 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value579 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant580 = golem_core_types.MakeRoleOther(value579)
+
+									default:
+										panic("unreachable")
+									}
+
+									option581 = witTypes.Some[golem_core_types.Role](variant580)
+								default:
+									panic("unreachable")
+								}
+
+								result582 = append(result582, golem_core_types.UnionBranch{value561, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant570, golem_core_types.MetadataEnvelope{option572, result574, result576, option578, option581}})
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result582})
+
+						case 32:
+							var option584 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option584 = witTypes.None[string]()
+							case 1:
+								value583 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option584 = witTypes.Some[string](value583)
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option584})
+
+						case 33:
+							var option586 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option586 = witTypes.None[string]()
+							case 1:
+								value585 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option586 = witTypes.Some[string](value585)
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option586})
+
+						case 34:
+							var option587 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option587 = witTypes.None[int32]()
+							case 1:
+
+								option587 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyFutureType(option587)
+
+						case 35:
+							var option588 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option588 = witTypes.None[int32]()
+							case 1:
+
+								option588 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant589 = golem_core_types.MakeSchemaTypeBodyStreamType(option588)
+
+						default:
+							panic("unreachable")
+						}
+						var option591 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option591 = witTypes.None[string]()
+						case 1:
+							value590 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option591 = witTypes.Some[string](value590)
+						default:
+							panic("unreachable")
+						}
+						result593 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value592 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result593 = append(result593, value592)
+						}
+
+						result595 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value594 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result595 = append(result595, value594)
+						}
+
+						var option597 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option597 = witTypes.None[string]()
+						case 1:
+							value596 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option597 = witTypes.Some[string](value596)
+						default:
+							panic("unreachable")
+						}
+						var option600 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option600 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant599 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant599 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant599 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant599 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value598 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant599 = golem_core_types.MakeRoleOther(value598)
+
+							default:
+								panic("unreachable")
+							}
+
+							option600 = witTypes.Some[golem_core_types.Role](variant599)
+						default:
+							panic("unreachable")
+						}
+
+						result601 = append(result601, golem_core_types.SchemaTypeNode{variant589, golem_core_types.MetadataEnvelope{option591, result593, result595, option597, option600}})
+					}
+
+					result605 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))))), index*(6*4))
+						value602 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option604 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option604 = witTypes.None[string]()
+						case 1:
+							value603 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option604 = witTypes.Some[string](value603)
+						default:
+							panic("unreachable")
+						}
+
+						result605 = append(result605, golem_core_types.SchemaTypeDef{value602, option604, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result629 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))))), index*(16+4*4))
+						var variant628 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value606 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant628 = golem_core_types.MakeSchemaValueNodeStringValue(value606)
+
+						case 13:
+							result607 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result607 = append(result607, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeRecordValue(result607)
+
+						case 14:
+							var option608 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option608 = witTypes.None[int32]()
+							case 1:
+
+								option608 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option608})
+
+						case 15:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result609 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result609 = append(result609, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeFlagsValue(result609)
+
+						case 17:
+							result610 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result610 = append(result610, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeTupleValue(result610)
+
+						case 18:
+							result611 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result611 = append(result611, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeListValue(result611)
+
+						case 19:
+							result612 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result612 = append(result612, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeFixedListValue(result612)
+
+						case 20:
+							result613 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result613 = append(result613, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeMapValue(result613)
+
+						case 21:
+							var option614 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option614 = witTypes.None[int32]()
+							case 1:
+
+								option614 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeOptionValue(option614)
+
+						case 22:
+							var variant617 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option615 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option615 = witTypes.None[int32]()
+								case 1:
+
+									option615 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant617 = golem_core_types.MakeResultValuePayloadOkValue(option615)
+
+							case 1:
+								var option616 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option616 = witTypes.None[int32]()
+								case 1:
+
+									option616 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant617 = golem_core_types.MakeResultValuePayloadErrValue(option616)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeResultValue(variant617)
+
+						case 23:
+							value618 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option620 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option620 = witTypes.None[string]()
+							case 1:
+								value619 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option620 = witTypes.Some[string](value619)
+							default:
+								panic("unreachable")
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value618, option620})
+
+						case 24:
+							value621 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option623 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option623 = witTypes.None[string]()
+							case 1:
+								value622 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option623 = witTypes.Some[string](value622)
+							default:
+								panic("unreachable")
+							}
+
+							variant628 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value621, option623})
+
+						case 25:
+							value624 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant628 = golem_core_types.MakeSchemaValueNodePathValue(value624)
+
+						case 26:
+							value625 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant628 = golem_core_types.MakeSchemaValueNodeUrlValue(value625)
+
+						case 27:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value626 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant628 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value626})
+
+						case 30:
+							value627 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant628 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value627, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant628 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result629 = append(result629, variant628)
+					}
+
+					option630 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result601, result605, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4)))}, golem_core_types.SchemaValueTree{result629, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4)))}})
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryEnd(EndParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), option630, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 9*4)))) != 0)})
+
+			case 3:
+				var option835 witTypes.Option[golem_core_types.TypedSchemaValue]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+				case 0:
+
+					option835 = witTypes.None[golem_core_types.TypedSchemaValue]()
+				case 1:
+					result806 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))), index*(56+22*4))
+						var variant794 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option637 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option637 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option632 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option632 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant631 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant631 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant631 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant631 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option632 = witTypes.Some[golem_core_types.NumericBound](variant631)
+								default:
+									panic("unreachable")
+								}
+								var option634 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option634 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant633 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant633 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant633 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant633 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option634 = witTypes.Some[golem_core_types.NumericBound](variant633)
+								default:
+									panic("unreachable")
+								}
+								var option636 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option636 = witTypes.None[string]()
+								case 1:
+									value635 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option636 = witTypes.Some[string](value635)
+								default:
+									panic("unreachable")
+								}
+
+								option637 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option632, option634, option636})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyS8Type(option637)
+
+						case 3:
+							var option644 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option644 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option639 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option639 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant638 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant638 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant638 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant638 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option639 = witTypes.Some[golem_core_types.NumericBound](variant638)
+								default:
+									panic("unreachable")
+								}
+								var option641 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option641 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant640 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant640 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant640 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant640 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option641 = witTypes.Some[golem_core_types.NumericBound](variant640)
+								default:
+									panic("unreachable")
+								}
+								var option643 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option643 = witTypes.None[string]()
+								case 1:
+									value642 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option643 = witTypes.Some[string](value642)
+								default:
+									panic("unreachable")
+								}
+
+								option644 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option639, option641, option643})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyS16Type(option644)
+
+						case 4:
+							var option651 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option651 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option646 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option646 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant645 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant645 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant645 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant645 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option646 = witTypes.Some[golem_core_types.NumericBound](variant645)
+								default:
+									panic("unreachable")
+								}
+								var option648 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option648 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant647 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant647 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant647 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant647 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option648 = witTypes.Some[golem_core_types.NumericBound](variant647)
+								default:
+									panic("unreachable")
+								}
+								var option650 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option650 = witTypes.None[string]()
+								case 1:
+									value649 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option650 = witTypes.Some[string](value649)
+								default:
+									panic("unreachable")
+								}
+
+								option651 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option646, option648, option650})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyS32Type(option651)
+
+						case 5:
+							var option658 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option658 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option653 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option653 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant652 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant652 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant652 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant652 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option653 = witTypes.Some[golem_core_types.NumericBound](variant652)
+								default:
+									panic("unreachable")
+								}
+								var option655 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option655 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant654 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant654 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant654 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant654 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option655 = witTypes.Some[golem_core_types.NumericBound](variant654)
+								default:
+									panic("unreachable")
+								}
+								var option657 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option657 = witTypes.None[string]()
+								case 1:
+									value656 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option657 = witTypes.Some[string](value656)
+								default:
+									panic("unreachable")
+								}
+
+								option658 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option653, option655, option657})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyS64Type(option658)
+
+						case 6:
+							var option665 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option665 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option660 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option660 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant659 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant659 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant659 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant659 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option660 = witTypes.Some[golem_core_types.NumericBound](variant659)
+								default:
+									panic("unreachable")
+								}
+								var option662 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option662 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant661 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant661 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant661 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant661 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option662 = witTypes.Some[golem_core_types.NumericBound](variant661)
+								default:
+									panic("unreachable")
+								}
+								var option664 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option664 = witTypes.None[string]()
+								case 1:
+									value663 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option664 = witTypes.Some[string](value663)
+								default:
+									panic("unreachable")
+								}
+
+								option665 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option660, option662, option664})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyU8Type(option665)
+
+						case 7:
+							var option672 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option672 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option667 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option667 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant666 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant666 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant666 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant666 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option667 = witTypes.Some[golem_core_types.NumericBound](variant666)
+								default:
+									panic("unreachable")
+								}
+								var option669 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option669 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant668 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant668 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant668 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant668 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option669 = witTypes.Some[golem_core_types.NumericBound](variant668)
+								default:
+									panic("unreachable")
+								}
+								var option671 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option671 = witTypes.None[string]()
+								case 1:
+									value670 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option671 = witTypes.Some[string](value670)
+								default:
+									panic("unreachable")
+								}
+
+								option672 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option667, option669, option671})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyU16Type(option672)
+
+						case 8:
+							var option679 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option679 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option674 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option674 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant673 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant673 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant673 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant673 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option674 = witTypes.Some[golem_core_types.NumericBound](variant673)
+								default:
+									panic("unreachable")
+								}
+								var option676 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option676 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant675 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant675 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant675 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant675 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option676 = witTypes.Some[golem_core_types.NumericBound](variant675)
+								default:
+									panic("unreachable")
+								}
+								var option678 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option678 = witTypes.None[string]()
+								case 1:
+									value677 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option678 = witTypes.Some[string](value677)
+								default:
+									panic("unreachable")
+								}
+
+								option679 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option674, option676, option678})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyU32Type(option679)
+
+						case 9:
+							var option686 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option686 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option681 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option681 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant680 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant680 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant680 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant680 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option681 = witTypes.Some[golem_core_types.NumericBound](variant680)
+								default:
+									panic("unreachable")
+								}
+								var option683 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option683 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant682 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant682 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant682 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant682 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option683 = witTypes.Some[golem_core_types.NumericBound](variant682)
+								default:
+									panic("unreachable")
+								}
+								var option685 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option685 = witTypes.None[string]()
+								case 1:
+									value684 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option685 = witTypes.Some[string](value684)
+								default:
+									panic("unreachable")
+								}
+
+								option686 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option681, option683, option685})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyU64Type(option686)
+
+						case 10:
+							var option693 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option693 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option688 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option688 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant687 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant687 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant687 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant687 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option688 = witTypes.Some[golem_core_types.NumericBound](variant687)
+								default:
+									panic("unreachable")
+								}
+								var option690 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option690 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant689 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant689 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant689 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant689 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option690 = witTypes.Some[golem_core_types.NumericBound](variant689)
+								default:
+									panic("unreachable")
+								}
+								var option692 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option692 = witTypes.None[string]()
+								case 1:
+									value691 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option692 = witTypes.Some[string](value691)
+								default:
+									panic("unreachable")
+								}
+
+								option693 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option688, option690, option692})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyF32Type(option693)
+
+						case 11:
+							var option700 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option700 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option695 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option695 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant694 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant694 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant694 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant694 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option695 = witTypes.Some[golem_core_types.NumericBound](variant694)
+								default:
+									panic("unreachable")
+								}
+								var option697 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option697 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant696 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant696 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant696 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant696 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option697 = witTypes.Some[golem_core_types.NumericBound](variant696)
+								default:
+									panic("unreachable")
+								}
+								var option699 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option699 = witTypes.None[string]()
+								case 1:
+									value698 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option699 = witTypes.Some[string](value698)
+								default:
+									panic("unreachable")
+								}
+
+								option700 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option695, option697, option699})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyF64Type(option700)
+
+						case 12:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result713 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value701 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option703 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option703 = witTypes.None[string]()
+								case 1:
+									value702 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option703 = witTypes.Some[string](value702)
+								default:
+									panic("unreachable")
+								}
+								result705 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value704 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result705 = append(result705, value704)
+								}
+
+								result707 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value706 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result707 = append(result707, value706)
+								}
+
+								var option709 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option709 = witTypes.None[string]()
+								case 1:
+									value708 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option709 = witTypes.Some[string](value708)
+								default:
+									panic("unreachable")
+								}
+								var option712 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option712 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant711 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant711 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant711 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant711 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value710 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant711 = golem_core_types.MakeRoleOther(value710)
+
+									default:
+										panic("unreachable")
+									}
+
+									option712 = witTypes.Some[golem_core_types.Role](variant711)
+								default:
+									panic("unreachable")
+								}
+
+								result713 = append(result713, golem_core_types.NamedFieldType{value701, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option703, result705, result707, option709, option712}})
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyRecordType(result713)
+
+						case 15:
+							result727 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value714 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option715 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option715 = witTypes.None[int32]()
+								case 1:
+
+									option715 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option717 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option717 = witTypes.None[string]()
+								case 1:
+									value716 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option717 = witTypes.Some[string](value716)
+								default:
+									panic("unreachable")
+								}
+								result719 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value718 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result719 = append(result719, value718)
+								}
+
+								result721 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value720 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result721 = append(result721, value720)
+								}
+
+								var option723 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option723 = witTypes.None[string]()
+								case 1:
+									value722 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option723 = witTypes.Some[string](value722)
+								default:
+									panic("unreachable")
+								}
+								var option726 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option726 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant725 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant725 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant725 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant725 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value724 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant725 = golem_core_types.MakeRoleOther(value724)
+
+									default:
+										panic("unreachable")
+									}
+
+									option726 = witTypes.Some[golem_core_types.Role](variant725)
+								default:
+									panic("unreachable")
+								}
+
+								result727 = append(result727, golem_core_types.VariantCaseType{value714, option715, golem_core_types.MetadataEnvelope{option717, result719, result721, option723, option726}})
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyVariantType(result727)
+
+						case 16:
+							result729 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value728 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result729 = append(result729, value728)
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyEnumType(result729)
+
+						case 17:
+							result731 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value730 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result731 = append(result731, value730)
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyFlagsType(result731)
+
+						case 18:
+							result732 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result732 = append(result732, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyTupleType(result732)
+
+						case 19:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option733 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option733 = witTypes.None[int32]()
+							case 1:
+
+								option733 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option734 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option734 = witTypes.None[int32]()
+							case 1:
+
+								option734 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option733, option734})
+
+						case 24:
+							var option737 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option737 = witTypes.None[[]string]()
+							case 1:
+								result736 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value735 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result736 = append(result736, value735)
+								}
+
+								option737 = witTypes.Some[[]string](result736)
+							default:
+								panic("unreachable")
+							}
+							var option738 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option738 = witTypes.None[uint32]()
+							case 1:
+
+								option738 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option739 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option739 = witTypes.None[uint32]()
+							case 1:
+
+								option739 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option741 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option741 = witTypes.None[string]()
+							case 1:
+								value740 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option741 = witTypes.Some[string](value740)
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option737, option738, option739, option741})
+
+						case 25:
+							var option744 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option744 = witTypes.None[[]string]()
+							case 1:
+								result743 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value742 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result743 = append(result743, value742)
+								}
+
+								option744 = witTypes.Some[[]string](result743)
+							default:
+								panic("unreachable")
+							}
+							var option745 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option745 = witTypes.None[uint32]()
+							case 1:
+
+								option745 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option746 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option746 = witTypes.None[uint32]()
+							case 1:
+
+								option746 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option744, option745, option746})
+
+						case 26:
+							var option749 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option749 = witTypes.None[[]string]()
+							case 1:
+								result748 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value747 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result748 = append(result748, value747)
+								}
+
+								option749 = witTypes.Some[[]string](result748)
+							default:
+								panic("unreachable")
+							}
+							var option752 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option752 = witTypes.None[[]string]()
+							case 1:
+								result751 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value750 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result751 = append(result751, value750)
+								}
+
+								option752 = witTypes.Some[[]string](result751)
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option749, option752})
+
+						case 27:
+							var option755 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option755 = witTypes.None[[]string]()
+							case 1:
+								result754 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value753 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result754 = append(result754, value753)
+								}
+
+								option755 = witTypes.Some[[]string](result754)
+							default:
+								panic("unreachable")
+							}
+							var option758 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option758 = witTypes.None[[]string]()
+							case 1:
+								result757 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value756 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result757 = append(result757, value756)
+								}
+
+								option758 = witTypes.Some[[]string](result757)
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option755, option758})
+
+						case 28:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value759 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result761 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value760 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result761 = append(result761, value760)
+							}
+
+							var option763 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option763 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value762 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option763 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value762})
+							default:
+								panic("unreachable")
+							}
+							var option765 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option765 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value764 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option765 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value764})
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value759, result761, option763, option765})
+
+						case 31:
+							result787 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value766 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant775 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value767 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant775 = golem_core_types.MakeDiscriminatorRulePrefix(value767)
+
+								case 1:
+									value768 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant775 = golem_core_types.MakeDiscriminatorRuleSuffix(value768)
+
+								case 2:
+									value769 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant775 = golem_core_types.MakeDiscriminatorRuleContains(value769)
+
+								case 3:
+									value770 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant775 = golem_core_types.MakeDiscriminatorRuleRegex(value770)
+
+								case 4:
+									value771 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option773 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option773 = witTypes.None[string]()
+									case 1:
+										value772 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option773 = witTypes.Some[string](value772)
+									default:
+										panic("unreachable")
+									}
+
+									variant775 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value771, option773})
+
+								case 5:
+									value774 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant775 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value774)
+
+								default:
+									panic("unreachable")
+								}
+								var option777 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option777 = witTypes.None[string]()
+								case 1:
+									value776 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option777 = witTypes.Some[string](value776)
+								default:
+									panic("unreachable")
+								}
+								result779 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value778 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result779 = append(result779, value778)
+								}
+
+								result781 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value780 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result781 = append(result781, value780)
+								}
+
+								var option783 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option783 = witTypes.None[string]()
+								case 1:
+									value782 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option783 = witTypes.Some[string](value782)
+								default:
+									panic("unreachable")
+								}
+								var option786 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option786 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant785 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant785 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant785 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant785 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value784 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant785 = golem_core_types.MakeRoleOther(value784)
+
+									default:
+										panic("unreachable")
+									}
+
+									option786 = witTypes.Some[golem_core_types.Role](variant785)
+								default:
+									panic("unreachable")
+								}
+
+								result787 = append(result787, golem_core_types.UnionBranch{value766, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant775, golem_core_types.MetadataEnvelope{option777, result779, result781, option783, option786}})
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result787})
+
+						case 32:
+							var option789 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option789 = witTypes.None[string]()
+							case 1:
+								value788 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option789 = witTypes.Some[string](value788)
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option789})
+
+						case 33:
+							var option791 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option791 = witTypes.None[string]()
+							case 1:
+								value790 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option791 = witTypes.Some[string](value790)
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option791})
+
+						case 34:
+							var option792 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option792 = witTypes.None[int32]()
+							case 1:
+
+								option792 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyFutureType(option792)
+
+						case 35:
+							var option793 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option793 = witTypes.None[int32]()
+							case 1:
+
+								option793 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant794 = golem_core_types.MakeSchemaTypeBodyStreamType(option793)
+
+						default:
+							panic("unreachable")
+						}
+						var option796 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option796 = witTypes.None[string]()
+						case 1:
+							value795 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option796 = witTypes.Some[string](value795)
+						default:
+							panic("unreachable")
+						}
+						result798 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value797 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result798 = append(result798, value797)
+						}
+
+						result800 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value799 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result800 = append(result800, value799)
+						}
+
+						var option802 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option802 = witTypes.None[string]()
+						case 1:
+							value801 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option802 = witTypes.Some[string](value801)
+						default:
+							panic("unreachable")
+						}
+						var option805 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option805 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant804 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant804 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant804 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant804 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value803 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant804 = golem_core_types.MakeRoleOther(value803)
+
+							default:
+								panic("unreachable")
+							}
+
+							option805 = witTypes.Some[golem_core_types.Role](variant804)
+						default:
+							panic("unreachable")
+						}
+
+						result806 = append(result806, golem_core_types.SchemaTypeNode{variant794, golem_core_types.MetadataEnvelope{option796, result798, result800, option802, option805}})
+					}
+
+					result810 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))))), index*(6*4))
+						value807 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option809 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option809 = witTypes.None[string]()
+						case 1:
+							value808 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option809 = witTypes.Some[string](value808)
+						default:
+							panic("unreachable")
+						}
+
+						result810 = append(result810, golem_core_types.SchemaTypeDef{value807, option809, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result834 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))))), index*(16+4*4))
+						var variant833 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value811 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant833 = golem_core_types.MakeSchemaValueNodeStringValue(value811)
+
+						case 13:
+							result812 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result812 = append(result812, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeRecordValue(result812)
+
+						case 14:
+							var option813 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option813 = witTypes.None[int32]()
+							case 1:
+
+								option813 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option813})
+
+						case 15:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result814 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result814 = append(result814, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeFlagsValue(result814)
+
+						case 17:
+							result815 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result815 = append(result815, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeTupleValue(result815)
+
+						case 18:
+							result816 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result816 = append(result816, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeListValue(result816)
+
+						case 19:
+							result817 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result817 = append(result817, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeFixedListValue(result817)
+
+						case 20:
+							result818 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result818 = append(result818, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeMapValue(result818)
+
+						case 21:
+							var option819 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option819 = witTypes.None[int32]()
+							case 1:
+
+								option819 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeOptionValue(option819)
+
+						case 22:
+							var variant822 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option820 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option820 = witTypes.None[int32]()
+								case 1:
+
+									option820 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant822 = golem_core_types.MakeResultValuePayloadOkValue(option820)
+
+							case 1:
+								var option821 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option821 = witTypes.None[int32]()
+								case 1:
+
+									option821 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant822 = golem_core_types.MakeResultValuePayloadErrValue(option821)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeResultValue(variant822)
+
+						case 23:
+							value823 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option825 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option825 = witTypes.None[string]()
+							case 1:
+								value824 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option825 = witTypes.Some[string](value824)
+							default:
+								panic("unreachable")
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value823, option825})
+
+						case 24:
+							value826 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option828 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option828 = witTypes.None[string]()
+							case 1:
+								value827 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option828 = witTypes.Some[string](value827)
+							default:
+								panic("unreachable")
+							}
+
+							variant833 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value826, option828})
+
+						case 25:
+							value829 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant833 = golem_core_types.MakeSchemaValueNodePathValue(value829)
+
+						case 26:
+							value830 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant833 = golem_core_types.MakeSchemaValueNodeUrlValue(value830)
+
+						case 27:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value831 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant833 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value831})
+
+						case 30:
+							value832 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant833 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value832, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant833 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result834 = append(result834, variant833)
+					}
+
+					option835 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result806, result810, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4)))}, golem_core_types.SchemaValueTree{result834, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4)))}})
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryCancelled(CancelledParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), option835})
+
+			case 4:
+				var variant1280 AgentInvocation
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+				case 0:
+					value836 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+					result1012 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))))), index*(56+22*4))
+						var variant1000 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option843 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option843 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option838 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option838 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant837 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant837 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant837 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant837 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option838 = witTypes.Some[golem_core_types.NumericBound](variant837)
+								default:
+									panic("unreachable")
+								}
+								var option840 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option840 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant839 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant839 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant839 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant839 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option840 = witTypes.Some[golem_core_types.NumericBound](variant839)
+								default:
+									panic("unreachable")
+								}
+								var option842 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option842 = witTypes.None[string]()
+								case 1:
+									value841 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option842 = witTypes.Some[string](value841)
+								default:
+									panic("unreachable")
+								}
+
+								option843 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option838, option840, option842})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyS8Type(option843)
+
+						case 3:
+							var option850 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option850 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option845 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option845 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant844 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant844 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant844 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant844 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option845 = witTypes.Some[golem_core_types.NumericBound](variant844)
+								default:
+									panic("unreachable")
+								}
+								var option847 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option847 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant846 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant846 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant846 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant846 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option847 = witTypes.Some[golem_core_types.NumericBound](variant846)
+								default:
+									panic("unreachable")
+								}
+								var option849 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option849 = witTypes.None[string]()
+								case 1:
+									value848 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option849 = witTypes.Some[string](value848)
+								default:
+									panic("unreachable")
+								}
+
+								option850 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option845, option847, option849})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyS16Type(option850)
+
+						case 4:
+							var option857 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option857 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option852 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option852 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant851 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant851 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant851 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant851 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option852 = witTypes.Some[golem_core_types.NumericBound](variant851)
+								default:
+									panic("unreachable")
+								}
+								var option854 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option854 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant853 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant853 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant853 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant853 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option854 = witTypes.Some[golem_core_types.NumericBound](variant853)
+								default:
+									panic("unreachable")
+								}
+								var option856 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option856 = witTypes.None[string]()
+								case 1:
+									value855 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option856 = witTypes.Some[string](value855)
+								default:
+									panic("unreachable")
+								}
+
+								option857 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option852, option854, option856})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyS32Type(option857)
+
+						case 5:
+							var option864 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option864 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option859 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option859 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant858 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant858 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant858 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant858 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option859 = witTypes.Some[golem_core_types.NumericBound](variant858)
+								default:
+									panic("unreachable")
+								}
+								var option861 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option861 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant860 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant860 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant860 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant860 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option861 = witTypes.Some[golem_core_types.NumericBound](variant860)
+								default:
+									panic("unreachable")
+								}
+								var option863 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option863 = witTypes.None[string]()
+								case 1:
+									value862 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option863 = witTypes.Some[string](value862)
+								default:
+									panic("unreachable")
+								}
+
+								option864 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option859, option861, option863})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyS64Type(option864)
+
+						case 6:
+							var option871 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option871 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option866 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option866 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant865 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant865 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant865 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant865 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option866 = witTypes.Some[golem_core_types.NumericBound](variant865)
+								default:
+									panic("unreachable")
+								}
+								var option868 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option868 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant867 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant867 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant867 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant867 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option868 = witTypes.Some[golem_core_types.NumericBound](variant867)
+								default:
+									panic("unreachable")
+								}
+								var option870 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option870 = witTypes.None[string]()
+								case 1:
+									value869 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option870 = witTypes.Some[string](value869)
+								default:
+									panic("unreachable")
+								}
+
+								option871 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option866, option868, option870})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyU8Type(option871)
+
+						case 7:
+							var option878 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option878 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option873 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option873 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant872 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant872 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant872 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant872 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option873 = witTypes.Some[golem_core_types.NumericBound](variant872)
+								default:
+									panic("unreachable")
+								}
+								var option875 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option875 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant874 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant874 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant874 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant874 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option875 = witTypes.Some[golem_core_types.NumericBound](variant874)
+								default:
+									panic("unreachable")
+								}
+								var option877 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option877 = witTypes.None[string]()
+								case 1:
+									value876 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option877 = witTypes.Some[string](value876)
+								default:
+									panic("unreachable")
+								}
+
+								option878 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option873, option875, option877})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyU16Type(option878)
+
+						case 8:
+							var option885 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option885 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option880 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option880 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant879 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant879 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant879 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant879 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option880 = witTypes.Some[golem_core_types.NumericBound](variant879)
+								default:
+									panic("unreachable")
+								}
+								var option882 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option882 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant881 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant881 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant881 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant881 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option882 = witTypes.Some[golem_core_types.NumericBound](variant881)
+								default:
+									panic("unreachable")
+								}
+								var option884 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option884 = witTypes.None[string]()
+								case 1:
+									value883 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option884 = witTypes.Some[string](value883)
+								default:
+									panic("unreachable")
+								}
+
+								option885 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option880, option882, option884})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyU32Type(option885)
+
+						case 9:
+							var option892 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option892 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option887 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option887 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant886 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant886 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant886 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant886 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option887 = witTypes.Some[golem_core_types.NumericBound](variant886)
+								default:
+									panic("unreachable")
+								}
+								var option889 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option889 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant888 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant888 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant888 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant888 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option889 = witTypes.Some[golem_core_types.NumericBound](variant888)
+								default:
+									panic("unreachable")
+								}
+								var option891 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option891 = witTypes.None[string]()
+								case 1:
+									value890 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option891 = witTypes.Some[string](value890)
+								default:
+									panic("unreachable")
+								}
+
+								option892 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option887, option889, option891})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyU64Type(option892)
+
+						case 10:
+							var option899 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option899 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option894 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option894 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant893 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant893 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant893 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant893 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option894 = witTypes.Some[golem_core_types.NumericBound](variant893)
+								default:
+									panic("unreachable")
+								}
+								var option896 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option896 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant895 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant895 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant895 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant895 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option896 = witTypes.Some[golem_core_types.NumericBound](variant895)
+								default:
+									panic("unreachable")
+								}
+								var option898 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option898 = witTypes.None[string]()
+								case 1:
+									value897 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option898 = witTypes.Some[string](value897)
+								default:
+									panic("unreachable")
+								}
+
+								option899 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option894, option896, option898})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyF32Type(option899)
+
+						case 11:
+							var option906 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option906 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option901 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option901 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant900 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant900 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant900 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant900 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option901 = witTypes.Some[golem_core_types.NumericBound](variant900)
+								default:
+									panic("unreachable")
+								}
+								var option903 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option903 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant902 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant902 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant902 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant902 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option903 = witTypes.Some[golem_core_types.NumericBound](variant902)
+								default:
+									panic("unreachable")
+								}
+								var option905 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option905 = witTypes.None[string]()
+								case 1:
+									value904 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option905 = witTypes.Some[string](value904)
+								default:
+									panic("unreachable")
+								}
+
+								option906 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option901, option903, option905})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyF64Type(option906)
+
+						case 12:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result919 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value907 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option909 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option909 = witTypes.None[string]()
+								case 1:
+									value908 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option909 = witTypes.Some[string](value908)
+								default:
+									panic("unreachable")
+								}
+								result911 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value910 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result911 = append(result911, value910)
+								}
+
+								result913 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value912 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result913 = append(result913, value912)
+								}
+
+								var option915 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option915 = witTypes.None[string]()
+								case 1:
+									value914 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option915 = witTypes.Some[string](value914)
+								default:
+									panic("unreachable")
+								}
+								var option918 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option918 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant917 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant917 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant917 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant917 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value916 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant917 = golem_core_types.MakeRoleOther(value916)
+
+									default:
+										panic("unreachable")
+									}
+
+									option918 = witTypes.Some[golem_core_types.Role](variant917)
+								default:
+									panic("unreachable")
+								}
+
+								result919 = append(result919, golem_core_types.NamedFieldType{value907, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option909, result911, result913, option915, option918}})
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyRecordType(result919)
+
+						case 15:
+							result933 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value920 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option921 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option921 = witTypes.None[int32]()
+								case 1:
+
+									option921 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option923 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option923 = witTypes.None[string]()
+								case 1:
+									value922 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option923 = witTypes.Some[string](value922)
+								default:
+									panic("unreachable")
+								}
+								result925 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value924 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result925 = append(result925, value924)
+								}
+
+								result927 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value926 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result927 = append(result927, value926)
+								}
+
+								var option929 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option929 = witTypes.None[string]()
+								case 1:
+									value928 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option929 = witTypes.Some[string](value928)
+								default:
+									panic("unreachable")
+								}
+								var option932 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option932 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant931 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant931 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant931 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant931 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value930 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant931 = golem_core_types.MakeRoleOther(value930)
+
+									default:
+										panic("unreachable")
+									}
+
+									option932 = witTypes.Some[golem_core_types.Role](variant931)
+								default:
+									panic("unreachable")
+								}
+
+								result933 = append(result933, golem_core_types.VariantCaseType{value920, option921, golem_core_types.MetadataEnvelope{option923, result925, result927, option929, option932}})
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyVariantType(result933)
+
+						case 16:
+							result935 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value934 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result935 = append(result935, value934)
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyEnumType(result935)
+
+						case 17:
+							result937 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value936 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result937 = append(result937, value936)
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyFlagsType(result937)
+
+						case 18:
+							result938 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result938 = append(result938, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyTupleType(result938)
+
+						case 19:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option939 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option939 = witTypes.None[int32]()
+							case 1:
+
+								option939 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option940 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option940 = witTypes.None[int32]()
+							case 1:
+
+								option940 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option939, option940})
+
+						case 24:
+							var option943 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option943 = witTypes.None[[]string]()
+							case 1:
+								result942 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value941 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result942 = append(result942, value941)
+								}
+
+								option943 = witTypes.Some[[]string](result942)
+							default:
+								panic("unreachable")
+							}
+							var option944 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option944 = witTypes.None[uint32]()
+							case 1:
+
+								option944 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option945 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option945 = witTypes.None[uint32]()
+							case 1:
+
+								option945 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option947 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option947 = witTypes.None[string]()
+							case 1:
+								value946 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option947 = witTypes.Some[string](value946)
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option943, option944, option945, option947})
+
+						case 25:
+							var option950 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option950 = witTypes.None[[]string]()
+							case 1:
+								result949 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value948 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result949 = append(result949, value948)
+								}
+
+								option950 = witTypes.Some[[]string](result949)
+							default:
+								panic("unreachable")
+							}
+							var option951 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option951 = witTypes.None[uint32]()
+							case 1:
+
+								option951 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option952 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option952 = witTypes.None[uint32]()
+							case 1:
+
+								option952 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option950, option951, option952})
+
+						case 26:
+							var option955 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option955 = witTypes.None[[]string]()
+							case 1:
+								result954 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value953 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result954 = append(result954, value953)
+								}
+
+								option955 = witTypes.Some[[]string](result954)
+							default:
+								panic("unreachable")
+							}
+							var option958 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option958 = witTypes.None[[]string]()
+							case 1:
+								result957 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value956 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result957 = append(result957, value956)
+								}
+
+								option958 = witTypes.Some[[]string](result957)
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option955, option958})
+
+						case 27:
+							var option961 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option961 = witTypes.None[[]string]()
+							case 1:
+								result960 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value959 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result960 = append(result960, value959)
+								}
+
+								option961 = witTypes.Some[[]string](result960)
+							default:
+								panic("unreachable")
+							}
+							var option964 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option964 = witTypes.None[[]string]()
+							case 1:
+								result963 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value962 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result963 = append(result963, value962)
+								}
+
+								option964 = witTypes.Some[[]string](result963)
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option961, option964})
+
+						case 28:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value965 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result967 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value966 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result967 = append(result967, value966)
+							}
+
+							var option969 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option969 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value968 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option969 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value968})
+							default:
+								panic("unreachable")
+							}
+							var option971 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option971 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value970 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option971 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value970})
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value965, result967, option969, option971})
+
+						case 31:
+							result993 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value972 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant981 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value973 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant981 = golem_core_types.MakeDiscriminatorRulePrefix(value973)
+
+								case 1:
+									value974 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant981 = golem_core_types.MakeDiscriminatorRuleSuffix(value974)
+
+								case 2:
+									value975 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant981 = golem_core_types.MakeDiscriminatorRuleContains(value975)
+
+								case 3:
+									value976 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant981 = golem_core_types.MakeDiscriminatorRuleRegex(value976)
+
+								case 4:
+									value977 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option979 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option979 = witTypes.None[string]()
+									case 1:
+										value978 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option979 = witTypes.Some[string](value978)
+									default:
+										panic("unreachable")
+									}
+
+									variant981 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value977, option979})
+
+								case 5:
+									value980 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant981 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value980)
+
+								default:
+									panic("unreachable")
+								}
+								var option983 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option983 = witTypes.None[string]()
+								case 1:
+									value982 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option983 = witTypes.Some[string](value982)
+								default:
+									panic("unreachable")
+								}
+								result985 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value984 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result985 = append(result985, value984)
+								}
+
+								result987 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value986 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result987 = append(result987, value986)
+								}
+
+								var option989 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option989 = witTypes.None[string]()
+								case 1:
+									value988 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option989 = witTypes.Some[string](value988)
+								default:
+									panic("unreachable")
+								}
+								var option992 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option992 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant991 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant991 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant991 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant991 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value990 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant991 = golem_core_types.MakeRoleOther(value990)
+
+									default:
+										panic("unreachable")
+									}
+
+									option992 = witTypes.Some[golem_core_types.Role](variant991)
+								default:
+									panic("unreachable")
+								}
+
+								result993 = append(result993, golem_core_types.UnionBranch{value972, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant981, golem_core_types.MetadataEnvelope{option983, result985, result987, option989, option992}})
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result993})
+
+						case 32:
+							var option995 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option995 = witTypes.None[string]()
+							case 1:
+								value994 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option995 = witTypes.Some[string](value994)
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option995})
+
+						case 33:
+							var option997 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option997 = witTypes.None[string]()
+							case 1:
+								value996 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option997 = witTypes.Some[string](value996)
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option997})
+
+						case 34:
+							var option998 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option998 = witTypes.None[int32]()
+							case 1:
+
+								option998 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyFutureType(option998)
+
+						case 35:
+							var option999 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option999 = witTypes.None[int32]()
+							case 1:
+
+								option999 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1000 = golem_core_types.MakeSchemaTypeBodyStreamType(option999)
+
+						default:
+							panic("unreachable")
+						}
+						var option1002 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option1002 = witTypes.None[string]()
+						case 1:
+							value1001 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option1002 = witTypes.Some[string](value1001)
+						default:
+							panic("unreachable")
+						}
+						result1004 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value1003 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1004 = append(result1004, value1003)
+						}
+
+						result1006 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value1005 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1006 = append(result1006, value1005)
+						}
+
+						var option1008 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option1008 = witTypes.None[string]()
+						case 1:
+							value1007 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option1008 = witTypes.Some[string](value1007)
+						default:
+							panic("unreachable")
+						}
+						var option1011 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option1011 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant1010 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant1010 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant1010 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant1010 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value1009 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant1010 = golem_core_types.MakeRoleOther(value1009)
+
+							default:
+								panic("unreachable")
+							}
+
+							option1011 = witTypes.Some[golem_core_types.Role](variant1010)
+						default:
+							panic("unreachable")
+						}
+
+						result1012 = append(result1012, golem_core_types.SchemaTypeNode{variant1000, golem_core_types.MetadataEnvelope{option1002, result1004, result1006, option1008, option1011}})
+					}
+
+					result1016 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))), index*(6*4))
+						value1013 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option1015 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option1015 = witTypes.None[string]()
+						case 1:
+							value1014 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option1015 = witTypes.Some[string](value1014)
+						default:
+							panic("unreachable")
+						}
+
+						result1016 = append(result1016, golem_core_types.SchemaTypeDef{value1013, option1015, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result1040 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 7*4))))), index*(16+4*4))
+						var variant1039 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value1017 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeStringValue(value1017)
+
+						case 13:
+							result1018 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1018 = append(result1018, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeRecordValue(result1018)
+
+						case 14:
+							var option1019 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option1019 = witTypes.None[int32]()
+							case 1:
+
+								option1019 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1019})
+
+						case 15:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result1020 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result1020 = append(result1020, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1020)
+
+						case 17:
+							result1021 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1021 = append(result1021, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeTupleValue(result1021)
+
+						case 18:
+							result1022 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1022 = append(result1022, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeListValue(result1022)
+
+						case 19:
+							result1023 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1023 = append(result1023, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1023)
+
+						case 20:
+							result1024 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result1024 = append(result1024, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeMapValue(result1024)
+
+						case 21:
+							var option1025 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1025 = witTypes.None[int32]()
+							case 1:
+
+								option1025 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeOptionValue(option1025)
+
+						case 22:
+							var variant1028 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option1026 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1026 = witTypes.None[int32]()
+								case 1:
+
+									option1026 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1028 = golem_core_types.MakeResultValuePayloadOkValue(option1026)
+
+							case 1:
+								var option1027 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1027 = witTypes.None[int32]()
+								case 1:
+
+									option1027 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1028 = golem_core_types.MakeResultValuePayloadErrValue(option1027)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeResultValue(variant1028)
+
+						case 23:
+							value1029 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1031 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1031 = witTypes.None[string]()
+							case 1:
+								value1030 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1031 = witTypes.Some[string](value1030)
+							default:
+								panic("unreachable")
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1029, option1031})
+
+						case 24:
+							value1032 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1034 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1034 = witTypes.None[string]()
+							case 1:
+								value1033 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1034 = witTypes.Some[string](value1033)
+							default:
+								panic("unreachable")
+							}
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1032, option1034})
+
+						case 25:
+							value1035 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1039 = golem_core_types.MakeSchemaValueNodePathValue(value1035)
+
+						case 26:
+							value1036 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeUrlValue(value1036)
+
+						case 27:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value1037 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1037})
+
+						case 30:
+							value1038 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1038, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant1039 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result1040 = append(result1040, variant1039)
+					}
+
+					value1041 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 11*4))))
+					result1043 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 13*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 13*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 12*4))))), index*(2*4))
+						value1042 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result1043 = append(result1043, value1042)
+					}
+
+					result1055 := make([][]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 15*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 15*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 14*4))))), index*(2*4))
+						result1054 := make([]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*(56+6*4))
+							var variant1053 SpanData
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value1044 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var option1046 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) {
+								case 0:
+
+									option1046 = witTypes.None[string]()
+								case 1:
+									value1045 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+									option1046 = witTypes.Some[string](value1045)
+								default:
+									panic("unreachable")
+								}
+								var option1047 witTypes.Option[uint64]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) {
+								case 0:
+
+									option1047 = witTypes.None[uint64]()
+								case 1:
+
+									option1047 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))))
+								default:
+									panic("unreachable")
+								}
+								result1051 := make([]golem_api_context.Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))), index*(5*4))
+									value1048 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+									var variant1050 golem_api_context.AttributeValue
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+									case 0:
+										value1049 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+										variant1050 = golem_api_context.MakeAttributeValueString(value1049)
+
+									default:
+										panic("unreachable")
+									}
+
+									result1051 = append(result1051, golem_api_context.Attribute{value1048, variant1050})
+								}
+
+								variant1053 = MakeSpanDataLocalSpan(LocalSpanData{value1044, wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))}, option1046, option1047, result1051, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)})
+
+							case 1:
+								value1052 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant1053 = MakeSpanDataExternalSpan(ExternalSpanData{value1052})
+
+							default:
+								panic("unreachable")
+							}
+
+							result1054 = append(result1054, variant1053)
+						}
+
+						result1055 = append(result1055, result1054)
+					}
+
+					variant1280 = MakeAgentInvocationAgentInitialization(AgentInitializationParameters{value836, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1012, result1016, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4)))}, golem_core_types.SchemaValueTree{result1040, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 9*4)))}}, value1041, result1043, result1055})
+
+				case 1:
+					value1056 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+					value1057 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))))
+					result1233 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))), index*(56+22*4))
+						var variant1221 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option1064 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1064 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1059 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1059 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1058 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1058 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1058 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1058 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1059 = witTypes.Some[golem_core_types.NumericBound](variant1058)
+								default:
+									panic("unreachable")
+								}
+								var option1061 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1061 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1060 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1060 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1060 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1060 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1061 = witTypes.Some[golem_core_types.NumericBound](variant1060)
+								default:
+									panic("unreachable")
+								}
+								var option1063 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1063 = witTypes.None[string]()
+								case 1:
+									value1062 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1063 = witTypes.Some[string](value1062)
+								default:
+									panic("unreachable")
+								}
+
+								option1064 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1059, option1061, option1063})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyS8Type(option1064)
+
+						case 3:
+							var option1071 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1071 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1066 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1066 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1065 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1065 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1065 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1065 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1066 = witTypes.Some[golem_core_types.NumericBound](variant1065)
+								default:
+									panic("unreachable")
+								}
+								var option1068 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1068 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1067 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1067 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1067 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1067 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1068 = witTypes.Some[golem_core_types.NumericBound](variant1067)
+								default:
+									panic("unreachable")
+								}
+								var option1070 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1070 = witTypes.None[string]()
+								case 1:
+									value1069 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1070 = witTypes.Some[string](value1069)
+								default:
+									panic("unreachable")
+								}
+
+								option1071 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1066, option1068, option1070})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyS16Type(option1071)
+
+						case 4:
+							var option1078 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1078 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1073 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1073 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1072 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1072 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1072 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1072 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1073 = witTypes.Some[golem_core_types.NumericBound](variant1072)
+								default:
+									panic("unreachable")
+								}
+								var option1075 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1075 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1074 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1074 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1074 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1074 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1075 = witTypes.Some[golem_core_types.NumericBound](variant1074)
+								default:
+									panic("unreachable")
+								}
+								var option1077 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1077 = witTypes.None[string]()
+								case 1:
+									value1076 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1077 = witTypes.Some[string](value1076)
+								default:
+									panic("unreachable")
+								}
+
+								option1078 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1073, option1075, option1077})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyS32Type(option1078)
+
+						case 5:
+							var option1085 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1085 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1080 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1080 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1079 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1079 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1079 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1079 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1080 = witTypes.Some[golem_core_types.NumericBound](variant1079)
+								default:
+									panic("unreachable")
+								}
+								var option1082 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1082 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1081 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1081 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1081 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1081 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1082 = witTypes.Some[golem_core_types.NumericBound](variant1081)
+								default:
+									panic("unreachable")
+								}
+								var option1084 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1084 = witTypes.None[string]()
+								case 1:
+									value1083 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1084 = witTypes.Some[string](value1083)
+								default:
+									panic("unreachable")
+								}
+
+								option1085 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1080, option1082, option1084})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyS64Type(option1085)
+
+						case 6:
+							var option1092 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1092 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1087 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1087 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1086 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1086 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1086 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1086 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1087 = witTypes.Some[golem_core_types.NumericBound](variant1086)
+								default:
+									panic("unreachable")
+								}
+								var option1089 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1089 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1088 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1088 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1088 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1088 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1089 = witTypes.Some[golem_core_types.NumericBound](variant1088)
+								default:
+									panic("unreachable")
+								}
+								var option1091 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1091 = witTypes.None[string]()
+								case 1:
+									value1090 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1091 = witTypes.Some[string](value1090)
+								default:
+									panic("unreachable")
+								}
+
+								option1092 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1087, option1089, option1091})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyU8Type(option1092)
+
+						case 7:
+							var option1099 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1099 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1094 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1094 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1093 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1093 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1093 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1093 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1094 = witTypes.Some[golem_core_types.NumericBound](variant1093)
+								default:
+									panic("unreachable")
+								}
+								var option1096 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1096 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1095 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1095 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1095 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1095 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1096 = witTypes.Some[golem_core_types.NumericBound](variant1095)
+								default:
+									panic("unreachable")
+								}
+								var option1098 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1098 = witTypes.None[string]()
+								case 1:
+									value1097 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1098 = witTypes.Some[string](value1097)
+								default:
+									panic("unreachable")
+								}
+
+								option1099 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1094, option1096, option1098})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyU16Type(option1099)
+
+						case 8:
+							var option1106 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1106 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1101 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1101 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1100 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1100 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1100 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1100 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1101 = witTypes.Some[golem_core_types.NumericBound](variant1100)
+								default:
+									panic("unreachable")
+								}
+								var option1103 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1103 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1102 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1102 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1102 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1102 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1103 = witTypes.Some[golem_core_types.NumericBound](variant1102)
+								default:
+									panic("unreachable")
+								}
+								var option1105 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1105 = witTypes.None[string]()
+								case 1:
+									value1104 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1105 = witTypes.Some[string](value1104)
+								default:
+									panic("unreachable")
+								}
+
+								option1106 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1101, option1103, option1105})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyU32Type(option1106)
+
+						case 9:
+							var option1113 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1113 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1108 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1108 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1107 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1107 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1107 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1107 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1108 = witTypes.Some[golem_core_types.NumericBound](variant1107)
+								default:
+									panic("unreachable")
+								}
+								var option1110 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1110 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1109 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1109 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1109 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1109 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1110 = witTypes.Some[golem_core_types.NumericBound](variant1109)
+								default:
+									panic("unreachable")
+								}
+								var option1112 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1112 = witTypes.None[string]()
+								case 1:
+									value1111 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1112 = witTypes.Some[string](value1111)
+								default:
+									panic("unreachable")
+								}
+
+								option1113 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1108, option1110, option1112})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyU64Type(option1113)
+
+						case 10:
+							var option1120 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1120 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1115 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1115 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1114 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1114 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1114 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1114 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1115 = witTypes.Some[golem_core_types.NumericBound](variant1114)
+								default:
+									panic("unreachable")
+								}
+								var option1117 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1117 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1116 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1116 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1116 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1116 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1117 = witTypes.Some[golem_core_types.NumericBound](variant1116)
+								default:
+									panic("unreachable")
+								}
+								var option1119 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1119 = witTypes.None[string]()
+								case 1:
+									value1118 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1119 = witTypes.Some[string](value1118)
+								default:
+									panic("unreachable")
+								}
+
+								option1120 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1115, option1117, option1119})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyF32Type(option1120)
+
+						case 11:
+							var option1127 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1127 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1122 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1122 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1121 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1121 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1121 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1121 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1122 = witTypes.Some[golem_core_types.NumericBound](variant1121)
+								default:
+									panic("unreachable")
+								}
+								var option1124 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1124 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1123 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1123 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1123 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1123 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1124 = witTypes.Some[golem_core_types.NumericBound](variant1123)
+								default:
+									panic("unreachable")
+								}
+								var option1126 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1126 = witTypes.None[string]()
+								case 1:
+									value1125 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1126 = witTypes.Some[string](value1125)
+								default:
+									panic("unreachable")
+								}
+
+								option1127 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1122, option1124, option1126})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyF64Type(option1127)
+
+						case 12:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result1140 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value1128 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1130 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option1130 = witTypes.None[string]()
+								case 1:
+									value1129 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option1130 = witTypes.Some[string](value1129)
+								default:
+									panic("unreachable")
+								}
+								result1132 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value1131 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1132 = append(result1132, value1131)
+								}
+
+								result1134 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value1133 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1134 = append(result1134, value1133)
+								}
+
+								var option1136 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option1136 = witTypes.None[string]()
+								case 1:
+									value1135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option1136 = witTypes.Some[string](value1135)
+								default:
+									panic("unreachable")
+								}
+								var option1139 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option1139 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1138 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant1138 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1138 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1138 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1137 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant1138 = golem_core_types.MakeRoleOther(value1137)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1139 = witTypes.Some[golem_core_types.Role](variant1138)
+								default:
+									panic("unreachable")
+								}
+
+								result1140 = append(result1140, golem_core_types.NamedFieldType{value1128, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1130, result1132, result1134, option1136, option1139}})
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyRecordType(result1140)
+
+						case 15:
+							result1154 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value1141 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1142 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option1142 = witTypes.None[int32]()
+								case 1:
+
+									option1142 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option1144 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option1144 = witTypes.None[string]()
+								case 1:
+									value1143 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option1144 = witTypes.Some[string](value1143)
+								default:
+									panic("unreachable")
+								}
+								result1146 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1145 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1146 = append(result1146, value1145)
+								}
+
+								result1148 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value1147 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1148 = append(result1148, value1147)
+								}
+
+								var option1150 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option1150 = witTypes.None[string]()
+								case 1:
+									value1149 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option1150 = witTypes.Some[string](value1149)
+								default:
+									panic("unreachable")
+								}
+								var option1153 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option1153 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1152 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant1152 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1152 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1152 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1151 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant1152 = golem_core_types.MakeRoleOther(value1151)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1153 = witTypes.Some[golem_core_types.Role](variant1152)
+								default:
+									panic("unreachable")
+								}
+
+								result1154 = append(result1154, golem_core_types.VariantCaseType{value1141, option1142, golem_core_types.MetadataEnvelope{option1144, result1146, result1148, option1150, option1153}})
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyVariantType(result1154)
+
+						case 16:
+							result1156 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1155 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1156 = append(result1156, value1155)
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyEnumType(result1156)
+
+						case 17:
+							result1158 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1157 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1158 = append(result1158, value1157)
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1158)
+
+						case 18:
+							result1159 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1159 = append(result1159, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyTupleType(result1159)
+
+						case 19:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option1160 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1160 = witTypes.None[int32]()
+							case 1:
+
+								option1160 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option1161 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option1161 = witTypes.None[int32]()
+							case 1:
+
+								option1161 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1160, option1161})
+
+						case 24:
+							var option1164 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1164 = witTypes.None[[]string]()
+							case 1:
+								result1163 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1162 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1163 = append(result1163, value1162)
+								}
+
+								option1164 = witTypes.Some[[]string](result1163)
+							default:
+								panic("unreachable")
+							}
+							var option1165 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1165 = witTypes.None[uint32]()
+							case 1:
+
+								option1165 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1166 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1166 = witTypes.None[uint32]()
+							case 1:
+
+								option1166 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1168 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option1168 = witTypes.None[string]()
+							case 1:
+								value1167 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option1168 = witTypes.Some[string](value1167)
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1164, option1165, option1166, option1168})
+
+						case 25:
+							var option1171 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1171 = witTypes.None[[]string]()
+							case 1:
+								result1170 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1170 = append(result1170, value1169)
+								}
+
+								option1171 = witTypes.Some[[]string](result1170)
+							default:
+								panic("unreachable")
+							}
+							var option1172 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1172 = witTypes.None[uint32]()
+							case 1:
+
+								option1172 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1173 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1173 = witTypes.None[uint32]()
+							case 1:
+
+								option1173 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1171, option1172, option1173})
+
+						case 26:
+							var option1176 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1176 = witTypes.None[[]string]()
+							case 1:
+								result1175 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value1174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1175 = append(result1175, value1174)
+								}
+
+								option1176 = witTypes.Some[[]string](result1175)
+							default:
+								panic("unreachable")
+							}
+							var option1179 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1179 = witTypes.None[[]string]()
+							case 1:
+								result1178 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1177 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1178 = append(result1178, value1177)
+								}
+
+								option1179 = witTypes.Some[[]string](result1178)
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option1176, option1179})
+
+						case 27:
+							var option1182 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1182 = witTypes.None[[]string]()
+							case 1:
+								result1181 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1180 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1181 = append(result1181, value1180)
+								}
+
+								option1182 = witTypes.Some[[]string](result1181)
+							default:
+								panic("unreachable")
+							}
+							var option1185 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1185 = witTypes.None[[]string]()
+							case 1:
+								result1184 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value1183 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1184 = append(result1184, value1183)
+								}
+
+								option1185 = witTypes.Some[[]string](result1184)
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1182, option1185})
+
+						case 28:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value1186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result1188 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value1187 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1188 = append(result1188, value1187)
+							}
+
+							var option1190 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1190 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1189 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option1190 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value1189})
+							default:
+								panic("unreachable")
+							}
+							var option1192 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option1192 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1191 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option1192 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value1191})
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1186, result1188, option1190, option1192})
+
+						case 31:
+							result1214 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value1193 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant1202 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value1194 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1202 = golem_core_types.MakeDiscriminatorRulePrefix(value1194)
+
+								case 1:
+									value1195 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1202 = golem_core_types.MakeDiscriminatorRuleSuffix(value1195)
+
+								case 2:
+									value1196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1202 = golem_core_types.MakeDiscriminatorRuleContains(value1196)
+
+								case 3:
+									value1197 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1202 = golem_core_types.MakeDiscriminatorRuleRegex(value1197)
+
+								case 4:
+									value1198 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option1200 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option1200 = witTypes.None[string]()
+									case 1:
+										value1199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option1200 = witTypes.Some[string](value1199)
+									default:
+										panic("unreachable")
+									}
+
+									variant1202 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1198, option1200})
+
+								case 5:
+									value1201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1202 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1201)
+
+								default:
+									panic("unreachable")
+								}
+								var option1204 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option1204 = witTypes.None[string]()
+								case 1:
+									value1203 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option1204 = witTypes.Some[string](value1203)
+								default:
+									panic("unreachable")
+								}
+								result1206 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value1205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1206 = append(result1206, value1205)
+								}
+
+								result1208 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value1207 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1208 = append(result1208, value1207)
+								}
+
+								var option1210 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option1210 = witTypes.None[string]()
+								case 1:
+									value1209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option1210 = witTypes.Some[string](value1209)
+								default:
+									panic("unreachable")
+								}
+								var option1213 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option1213 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1212 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant1212 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1212 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1212 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1211 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant1212 = golem_core_types.MakeRoleOther(value1211)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1213 = witTypes.Some[golem_core_types.Role](variant1212)
+								default:
+									panic("unreachable")
+								}
+
+								result1214 = append(result1214, golem_core_types.UnionBranch{value1193, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1202, golem_core_types.MetadataEnvelope{option1204, result1206, result1208, option1210, option1213}})
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1214})
+
+						case 32:
+							var option1216 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1216 = witTypes.None[string]()
+							case 1:
+								value1215 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option1216 = witTypes.Some[string](value1215)
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1216})
+
+						case 33:
+							var option1218 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1218 = witTypes.None[string]()
+							case 1:
+								value1217 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option1218 = witTypes.Some[string](value1217)
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1218})
+
+						case 34:
+							var option1219 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1219 = witTypes.None[int32]()
+							case 1:
+
+								option1219 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyFutureType(option1219)
+
+						case 35:
+							var option1220 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1220 = witTypes.None[int32]()
+							case 1:
+
+								option1220 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1221 = golem_core_types.MakeSchemaTypeBodyStreamType(option1220)
+
+						default:
+							panic("unreachable")
+						}
+						var option1223 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option1223 = witTypes.None[string]()
+						case 1:
+							value1222 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option1223 = witTypes.Some[string](value1222)
+						default:
+							panic("unreachable")
+						}
+						result1225 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value1224 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1225 = append(result1225, value1224)
+						}
+
+						result1227 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value1226 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1227 = append(result1227, value1226)
+						}
+
+						var option1229 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option1229 = witTypes.None[string]()
+						case 1:
+							value1228 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option1229 = witTypes.Some[string](value1228)
+						default:
+							panic("unreachable")
+						}
+						var option1232 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option1232 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant1231 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant1231 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant1231 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant1231 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value1230 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant1231 = golem_core_types.MakeRoleOther(value1230)
+
+							default:
+								panic("unreachable")
+							}
+
+							option1232 = witTypes.Some[golem_core_types.Role](variant1231)
+						default:
+							panic("unreachable")
+						}
+
+						result1233 = append(result1233, golem_core_types.SchemaTypeNode{variant1221, golem_core_types.MetadataEnvelope{option1223, result1225, result1227, option1229, option1232}})
+					}
+
+					result1237 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))))), index*(6*4))
+						value1234 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option1236 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option1236 = witTypes.None[string]()
+						case 1:
+							value1235 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option1236 = witTypes.Some[string](value1235)
+						default:
+							panic("unreachable")
+						}
+
+						result1237 = append(result1237, golem_core_types.SchemaTypeDef{value1234, option1236, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result1261 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 10*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 10*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 9*4))))), index*(16+4*4))
+						var variant1260 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value1238 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeStringValue(value1238)
+
+						case 13:
+							result1239 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1239 = append(result1239, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeRecordValue(result1239)
+
+						case 14:
+							var option1240 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option1240 = witTypes.None[int32]()
+							case 1:
+
+								option1240 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1240})
+
+						case 15:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result1241 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result1241 = append(result1241, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1241)
+
+						case 17:
+							result1242 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1242 = append(result1242, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeTupleValue(result1242)
+
+						case 18:
+							result1243 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1243 = append(result1243, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeListValue(result1243)
+
+						case 19:
+							result1244 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1244 = append(result1244, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1244)
+
+						case 20:
+							result1245 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result1245 = append(result1245, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeMapValue(result1245)
+
+						case 21:
+							var option1246 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1246 = witTypes.None[int32]()
+							case 1:
+
+								option1246 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeOptionValue(option1246)
+
+						case 22:
+							var variant1249 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option1247 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1247 = witTypes.None[int32]()
+								case 1:
+
+									option1247 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1249 = golem_core_types.MakeResultValuePayloadOkValue(option1247)
+
+							case 1:
+								var option1248 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1248 = witTypes.None[int32]()
+								case 1:
+
+									option1248 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1249 = golem_core_types.MakeResultValuePayloadErrValue(option1248)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeResultValue(variant1249)
+
+						case 23:
+							value1250 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1252 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1252 = witTypes.None[string]()
+							case 1:
+								value1251 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1252 = witTypes.Some[string](value1251)
+							default:
+								panic("unreachable")
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1250, option1252})
+
+						case 24:
+							value1253 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1255 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1255 = witTypes.None[string]()
+							case 1:
+								value1254 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1255 = witTypes.Some[string](value1254)
+							default:
+								panic("unreachable")
+							}
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1253, option1255})
+
+						case 25:
+							value1256 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1260 = golem_core_types.MakeSchemaValueNodePathValue(value1256)
+
+						case 26:
+							value1257 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeUrlValue(value1257)
+
+						case 27:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value1258 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1258})
+
+						case 30:
+							value1259 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1259, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant1260 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result1261 = append(result1261, variant1260)
+					}
+
+					value1262 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 12*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 13*4))))
+					result1264 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 15*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 15*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 14*4))))), index*(2*4))
+						value1263 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result1264 = append(result1264, value1263)
+					}
+
+					result1276 := make([][]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 17*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 17*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 16*4))))), index*(2*4))
+						result1275 := make([]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*(56+6*4))
+							var variant1274 SpanData
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value1265 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var option1267 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) {
+								case 0:
+
+									option1267 = witTypes.None[string]()
+								case 1:
+									value1266 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+									option1267 = witTypes.Some[string](value1266)
+								default:
+									panic("unreachable")
+								}
+								var option1268 witTypes.Option[uint64]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) {
+								case 0:
+
+									option1268 = witTypes.None[uint64]()
+								case 1:
+
+									option1268 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))))
+								default:
+									panic("unreachable")
+								}
+								result1272 := make([]golem_api_context.Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))), index*(5*4))
+									value1269 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+									var variant1271 golem_api_context.AttributeValue
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+									case 0:
+										value1270 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+										variant1271 = golem_api_context.MakeAttributeValueString(value1270)
+
+									default:
+										panic("unreachable")
+									}
+
+									result1272 = append(result1272, golem_api_context.Attribute{value1269, variant1271})
+								}
+
+								variant1274 = MakeSpanDataLocalSpan(LocalSpanData{value1265, wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))}, option1267, option1268, result1272, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)})
+
+							case 1:
+								value1273 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant1274 = MakeSpanDataExternalSpan(ExternalSpanData{value1273})
+
+							default:
+								panic("unreachable")
+							}
+
+							result1275 = append(result1275, variant1274)
+						}
+
+						result1276 = append(result1276, result1275)
+					}
+
+					variant1280 = MakeAgentInvocationAgentMethodInvocation(AgentMethodInvocationParameters{value1056, value1057, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1233, result1237, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4)))}, golem_core_types.SchemaValueTree{result1261, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 11*4)))}}, value1262, result1264, result1276})
+
+				case 2:
+
+					variant1280 = MakeAgentInvocationSaveSnapshot()
+
+				case 3:
+					value1277 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+					value1278 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))))
+
+					variant1280 = MakeAgentInvocationLoadSnapshot(LoadSnapshotParameters{SnapshotData{value1277, value1278}})
+
+				case 4:
+					value1279 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+
+					variant1280 = MakeAgentInvocationProcessOplogEntries(ProcessOplogEntriesParameters{value1279})
+
+				case 5:
+
+					variant1280 = MakeAgentInvocationManualUpdate(ManualUpdateParameters{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))})
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryAgentInvocationStarted(AgentInvocationStartedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, variant1280})
+
+			case 5:
+				var variant1695 AgentInvocationResult
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+				case 0:
+					result1456 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))), index*(56+22*4))
+						var variant1444 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option1287 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1287 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1282 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1282 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1281 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1281 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1281 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1281 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1282 = witTypes.Some[golem_core_types.NumericBound](variant1281)
+								default:
+									panic("unreachable")
+								}
+								var option1284 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1284 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1283 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1283 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1283 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1283 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1284 = witTypes.Some[golem_core_types.NumericBound](variant1283)
+								default:
+									panic("unreachable")
+								}
+								var option1286 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1286 = witTypes.None[string]()
+								case 1:
+									value1285 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1286 = witTypes.Some[string](value1285)
+								default:
+									panic("unreachable")
+								}
+
+								option1287 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1282, option1284, option1286})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyS8Type(option1287)
+
+						case 3:
+							var option1294 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1294 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1289 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1289 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1288 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1288 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1288 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1288 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1289 = witTypes.Some[golem_core_types.NumericBound](variant1288)
+								default:
+									panic("unreachable")
+								}
+								var option1291 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1291 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1290 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1290 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1290 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1290 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1291 = witTypes.Some[golem_core_types.NumericBound](variant1290)
+								default:
+									panic("unreachable")
+								}
+								var option1293 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1293 = witTypes.None[string]()
+								case 1:
+									value1292 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1293 = witTypes.Some[string](value1292)
+								default:
+									panic("unreachable")
+								}
+
+								option1294 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1289, option1291, option1293})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyS16Type(option1294)
+
+						case 4:
+							var option1301 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1301 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1296 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1296 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1295 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1295 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1295 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1295 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1296 = witTypes.Some[golem_core_types.NumericBound](variant1295)
+								default:
+									panic("unreachable")
+								}
+								var option1298 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1298 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1297 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1297 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1297 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1297 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1298 = witTypes.Some[golem_core_types.NumericBound](variant1297)
+								default:
+									panic("unreachable")
+								}
+								var option1300 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1300 = witTypes.None[string]()
+								case 1:
+									value1299 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1300 = witTypes.Some[string](value1299)
+								default:
+									panic("unreachable")
+								}
+
+								option1301 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1296, option1298, option1300})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyS32Type(option1301)
+
+						case 5:
+							var option1308 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1308 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1303 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1303 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1302 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1302 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1302 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1302 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1303 = witTypes.Some[golem_core_types.NumericBound](variant1302)
+								default:
+									panic("unreachable")
+								}
+								var option1305 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1305 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1304 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1304 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1304 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1304 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1305 = witTypes.Some[golem_core_types.NumericBound](variant1304)
+								default:
+									panic("unreachable")
+								}
+								var option1307 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1307 = witTypes.None[string]()
+								case 1:
+									value1306 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1307 = witTypes.Some[string](value1306)
+								default:
+									panic("unreachable")
+								}
+
+								option1308 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1303, option1305, option1307})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyS64Type(option1308)
+
+						case 6:
+							var option1315 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1315 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1310 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1310 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1309 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1309 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1309 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1309 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1310 = witTypes.Some[golem_core_types.NumericBound](variant1309)
+								default:
+									panic("unreachable")
+								}
+								var option1312 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1312 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1311 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1311 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1311 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1311 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1312 = witTypes.Some[golem_core_types.NumericBound](variant1311)
+								default:
+									panic("unreachable")
+								}
+								var option1314 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1314 = witTypes.None[string]()
+								case 1:
+									value1313 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1314 = witTypes.Some[string](value1313)
+								default:
+									panic("unreachable")
+								}
+
+								option1315 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1310, option1312, option1314})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyU8Type(option1315)
+
+						case 7:
+							var option1322 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1322 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1317 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1317 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1316 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1316 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1316 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1316 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1317 = witTypes.Some[golem_core_types.NumericBound](variant1316)
+								default:
+									panic("unreachable")
+								}
+								var option1319 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1319 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1318 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1318 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1318 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1318 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1319 = witTypes.Some[golem_core_types.NumericBound](variant1318)
+								default:
+									panic("unreachable")
+								}
+								var option1321 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1321 = witTypes.None[string]()
+								case 1:
+									value1320 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1321 = witTypes.Some[string](value1320)
+								default:
+									panic("unreachable")
+								}
+
+								option1322 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1317, option1319, option1321})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyU16Type(option1322)
+
+						case 8:
+							var option1329 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1329 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1324 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1324 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1323 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1323 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1323 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1323 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1324 = witTypes.Some[golem_core_types.NumericBound](variant1323)
+								default:
+									panic("unreachable")
+								}
+								var option1326 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1326 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1325 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1325 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1325 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1325 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1326 = witTypes.Some[golem_core_types.NumericBound](variant1325)
+								default:
+									panic("unreachable")
+								}
+								var option1328 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1328 = witTypes.None[string]()
+								case 1:
+									value1327 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1328 = witTypes.Some[string](value1327)
+								default:
+									panic("unreachable")
+								}
+
+								option1329 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1324, option1326, option1328})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyU32Type(option1329)
+
+						case 9:
+							var option1336 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1336 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1331 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1331 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1330 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1330 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1330 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1330 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1331 = witTypes.Some[golem_core_types.NumericBound](variant1330)
+								default:
+									panic("unreachable")
+								}
+								var option1333 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1333 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1332 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1332 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1332 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1332 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1333 = witTypes.Some[golem_core_types.NumericBound](variant1332)
+								default:
+									panic("unreachable")
+								}
+								var option1335 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1335 = witTypes.None[string]()
+								case 1:
+									value1334 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1335 = witTypes.Some[string](value1334)
+								default:
+									panic("unreachable")
+								}
+
+								option1336 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1331, option1333, option1335})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyU64Type(option1336)
+
+						case 10:
+							var option1343 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1343 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1338 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1338 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1337 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1337 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1337 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1337 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1338 = witTypes.Some[golem_core_types.NumericBound](variant1337)
+								default:
+									panic("unreachable")
+								}
+								var option1340 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1340 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1339 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1339 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1339 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1339 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1340 = witTypes.Some[golem_core_types.NumericBound](variant1339)
+								default:
+									panic("unreachable")
+								}
+								var option1342 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1342 = witTypes.None[string]()
+								case 1:
+									value1341 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1342 = witTypes.Some[string](value1341)
+								default:
+									panic("unreachable")
+								}
+
+								option1343 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1338, option1340, option1342})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyF32Type(option1343)
+
+						case 11:
+							var option1350 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1350 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1345 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1345 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1344 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1344 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1344 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1344 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1345 = witTypes.Some[golem_core_types.NumericBound](variant1344)
+								default:
+									panic("unreachable")
+								}
+								var option1347 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1347 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1346 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1346 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1346 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1346 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1347 = witTypes.Some[golem_core_types.NumericBound](variant1346)
+								default:
+									panic("unreachable")
+								}
+								var option1349 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1349 = witTypes.None[string]()
+								case 1:
+									value1348 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1349 = witTypes.Some[string](value1348)
+								default:
+									panic("unreachable")
+								}
+
+								option1350 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1345, option1347, option1349})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyF64Type(option1350)
+
+						case 12:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result1363 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value1351 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1353 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option1353 = witTypes.None[string]()
+								case 1:
+									value1352 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option1353 = witTypes.Some[string](value1352)
+								default:
+									panic("unreachable")
+								}
+								result1355 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value1354 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1355 = append(result1355, value1354)
+								}
+
+								result1357 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value1356 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1357 = append(result1357, value1356)
+								}
+
+								var option1359 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option1359 = witTypes.None[string]()
+								case 1:
+									value1358 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option1359 = witTypes.Some[string](value1358)
+								default:
+									panic("unreachable")
+								}
+								var option1362 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option1362 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1361 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant1361 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1361 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1361 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1360 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant1361 = golem_core_types.MakeRoleOther(value1360)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1362 = witTypes.Some[golem_core_types.Role](variant1361)
+								default:
+									panic("unreachable")
+								}
+
+								result1363 = append(result1363, golem_core_types.NamedFieldType{value1351, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1353, result1355, result1357, option1359, option1362}})
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyRecordType(result1363)
+
+						case 15:
+							result1377 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value1364 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1365 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option1365 = witTypes.None[int32]()
+								case 1:
+
+									option1365 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option1367 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option1367 = witTypes.None[string]()
+								case 1:
+									value1366 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option1367 = witTypes.Some[string](value1366)
+								default:
+									panic("unreachable")
+								}
+								result1369 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1368 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1369 = append(result1369, value1368)
+								}
+
+								result1371 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value1370 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1371 = append(result1371, value1370)
+								}
+
+								var option1373 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option1373 = witTypes.None[string]()
+								case 1:
+									value1372 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option1373 = witTypes.Some[string](value1372)
+								default:
+									panic("unreachable")
+								}
+								var option1376 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option1376 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1375 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant1375 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1375 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1375 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1374 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant1375 = golem_core_types.MakeRoleOther(value1374)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1376 = witTypes.Some[golem_core_types.Role](variant1375)
+								default:
+									panic("unreachable")
+								}
+
+								result1377 = append(result1377, golem_core_types.VariantCaseType{value1364, option1365, golem_core_types.MetadataEnvelope{option1367, result1369, result1371, option1373, option1376}})
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyVariantType(result1377)
+
+						case 16:
+							result1379 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1378 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1379 = append(result1379, value1378)
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyEnumType(result1379)
+
+						case 17:
+							result1381 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1380 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1381 = append(result1381, value1380)
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1381)
+
+						case 18:
+							result1382 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1382 = append(result1382, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyTupleType(result1382)
+
+						case 19:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option1383 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1383 = witTypes.None[int32]()
+							case 1:
+
+								option1383 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option1384 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option1384 = witTypes.None[int32]()
+							case 1:
+
+								option1384 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1383, option1384})
+
+						case 24:
+							var option1387 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1387 = witTypes.None[[]string]()
+							case 1:
+								result1386 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1385 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1386 = append(result1386, value1385)
+								}
+
+								option1387 = witTypes.Some[[]string](result1386)
+							default:
+								panic("unreachable")
+							}
+							var option1388 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1388 = witTypes.None[uint32]()
+							case 1:
+
+								option1388 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1389 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1389 = witTypes.None[uint32]()
+							case 1:
+
+								option1389 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1391 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option1391 = witTypes.None[string]()
+							case 1:
+								value1390 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option1391 = witTypes.Some[string](value1390)
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1387, option1388, option1389, option1391})
+
+						case 25:
+							var option1394 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1394 = witTypes.None[[]string]()
+							case 1:
+								result1393 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1392 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1393 = append(result1393, value1392)
+								}
+
+								option1394 = witTypes.Some[[]string](result1393)
+							default:
+								panic("unreachable")
+							}
+							var option1395 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1395 = witTypes.None[uint32]()
+							case 1:
+
+								option1395 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1396 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1396 = witTypes.None[uint32]()
+							case 1:
+
+								option1396 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1394, option1395, option1396})
+
+						case 26:
+							var option1399 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1399 = witTypes.None[[]string]()
+							case 1:
+								result1398 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value1397 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1398 = append(result1398, value1397)
+								}
+
+								option1399 = witTypes.Some[[]string](result1398)
+							default:
+								panic("unreachable")
+							}
+							var option1402 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1402 = witTypes.None[[]string]()
+							case 1:
+								result1401 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1400 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1401 = append(result1401, value1400)
+								}
+
+								option1402 = witTypes.Some[[]string](result1401)
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option1399, option1402})
+
+						case 27:
+							var option1405 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1405 = witTypes.None[[]string]()
+							case 1:
+								result1404 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1403 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1404 = append(result1404, value1403)
+								}
+
+								option1405 = witTypes.Some[[]string](result1404)
+							default:
+								panic("unreachable")
+							}
+							var option1408 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1408 = witTypes.None[[]string]()
+							case 1:
+								result1407 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value1406 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1407 = append(result1407, value1406)
+								}
+
+								option1408 = witTypes.Some[[]string](result1407)
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1405, option1408})
+
+						case 28:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value1409 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result1411 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value1410 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1411 = append(result1411, value1410)
+							}
+
+							var option1413 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1413 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1412 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option1413 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value1412})
+							default:
+								panic("unreachable")
+							}
+							var option1415 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option1415 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1414 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option1415 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value1414})
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1409, result1411, option1413, option1415})
+
+						case 31:
+							result1437 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value1416 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant1425 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value1417 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1425 = golem_core_types.MakeDiscriminatorRulePrefix(value1417)
+
+								case 1:
+									value1418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1425 = golem_core_types.MakeDiscriminatorRuleSuffix(value1418)
+
+								case 2:
+									value1419 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1425 = golem_core_types.MakeDiscriminatorRuleContains(value1419)
+
+								case 3:
+									value1420 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1425 = golem_core_types.MakeDiscriminatorRuleRegex(value1420)
+
+								case 4:
+									value1421 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option1423 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option1423 = witTypes.None[string]()
+									case 1:
+										value1422 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option1423 = witTypes.Some[string](value1422)
+									default:
+										panic("unreachable")
+									}
+
+									variant1425 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1421, option1423})
+
+								case 5:
+									value1424 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1425 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1424)
+
+								default:
+									panic("unreachable")
+								}
+								var option1427 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option1427 = witTypes.None[string]()
+								case 1:
+									value1426 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option1427 = witTypes.Some[string](value1426)
+								default:
+									panic("unreachable")
+								}
+								result1429 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value1428 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1429 = append(result1429, value1428)
+								}
+
+								result1431 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value1430 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1431 = append(result1431, value1430)
+								}
+
+								var option1433 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option1433 = witTypes.None[string]()
+								case 1:
+									value1432 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option1433 = witTypes.Some[string](value1432)
+								default:
+									panic("unreachable")
+								}
+								var option1436 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option1436 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1435 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant1435 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1435 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1435 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1434 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant1435 = golem_core_types.MakeRoleOther(value1434)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1436 = witTypes.Some[golem_core_types.Role](variant1435)
+								default:
+									panic("unreachable")
+								}
+
+								result1437 = append(result1437, golem_core_types.UnionBranch{value1416, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1425, golem_core_types.MetadataEnvelope{option1427, result1429, result1431, option1433, option1436}})
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1437})
+
+						case 32:
+							var option1439 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1439 = witTypes.None[string]()
+							case 1:
+								value1438 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option1439 = witTypes.Some[string](value1438)
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1439})
+
+						case 33:
+							var option1441 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1441 = witTypes.None[string]()
+							case 1:
+								value1440 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option1441 = witTypes.Some[string](value1440)
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1441})
+
+						case 34:
+							var option1442 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1442 = witTypes.None[int32]()
+							case 1:
+
+								option1442 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyFutureType(option1442)
+
+						case 35:
+							var option1443 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1443 = witTypes.None[int32]()
+							case 1:
+
+								option1443 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1444 = golem_core_types.MakeSchemaTypeBodyStreamType(option1443)
+
+						default:
+							panic("unreachable")
+						}
+						var option1446 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option1446 = witTypes.None[string]()
+						case 1:
+							value1445 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option1446 = witTypes.Some[string](value1445)
+						default:
+							panic("unreachable")
+						}
+						result1448 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value1447 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1448 = append(result1448, value1447)
+						}
+
+						result1450 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value1449 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1450 = append(result1450, value1449)
+						}
+
+						var option1452 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option1452 = witTypes.None[string]()
+						case 1:
+							value1451 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option1452 = witTypes.Some[string](value1451)
+						default:
+							panic("unreachable")
+						}
+						var option1455 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option1455 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant1454 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant1454 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant1454 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant1454 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value1453 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant1454 = golem_core_types.MakeRoleOther(value1453)
+
+							default:
+								panic("unreachable")
+							}
+
+							option1455 = witTypes.Some[golem_core_types.Role](variant1454)
+						default:
+							panic("unreachable")
+						}
+
+						result1456 = append(result1456, golem_core_types.SchemaTypeNode{variant1444, golem_core_types.MetadataEnvelope{option1446, result1448, result1450, option1452, option1455}})
+					}
+
+					result1460 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))), index*(6*4))
+						value1457 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option1459 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option1459 = witTypes.None[string]()
+						case 1:
+							value1458 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option1459 = witTypes.Some[string](value1458)
+						default:
+							panic("unreachable")
+						}
+
+						result1460 = append(result1460, golem_core_types.SchemaTypeDef{value1457, option1459, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result1484 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))))), index*(16+4*4))
+						var variant1483 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value1461 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeStringValue(value1461)
+
+						case 13:
+							result1462 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1462 = append(result1462, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeRecordValue(result1462)
+
+						case 14:
+							var option1463 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option1463 = witTypes.None[int32]()
+							case 1:
+
+								option1463 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1463})
+
+						case 15:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result1464 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result1464 = append(result1464, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1464)
+
+						case 17:
+							result1465 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1465 = append(result1465, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeTupleValue(result1465)
+
+						case 18:
+							result1466 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1466 = append(result1466, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeListValue(result1466)
+
+						case 19:
+							result1467 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1467 = append(result1467, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1467)
+
+						case 20:
+							result1468 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result1468 = append(result1468, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeMapValue(result1468)
+
+						case 21:
+							var option1469 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1469 = witTypes.None[int32]()
+							case 1:
+
+								option1469 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeOptionValue(option1469)
+
+						case 22:
+							var variant1472 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option1470 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1470 = witTypes.None[int32]()
+								case 1:
+
+									option1470 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1472 = golem_core_types.MakeResultValuePayloadOkValue(option1470)
+
+							case 1:
+								var option1471 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1471 = witTypes.None[int32]()
+								case 1:
+
+									option1471 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1472 = golem_core_types.MakeResultValuePayloadErrValue(option1471)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeResultValue(variant1472)
+
+						case 23:
+							value1473 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1475 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1475 = witTypes.None[string]()
+							case 1:
+								value1474 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1475 = witTypes.Some[string](value1474)
+							default:
+								panic("unreachable")
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1473, option1475})
+
+						case 24:
+							value1476 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1478 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1478 = witTypes.None[string]()
+							case 1:
+								value1477 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1478 = witTypes.Some[string](value1477)
+							default:
+								panic("unreachable")
+							}
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1476, option1478})
+
+						case 25:
+							value1479 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1483 = golem_core_types.MakeSchemaValueNodePathValue(value1479)
+
+						case 26:
+							value1480 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeUrlValue(value1480)
+
+						case 27:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value1481 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1481})
+
+						case 30:
+							value1482 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1482, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant1483 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result1484 = append(result1484, variant1483)
+					}
+
+					variant1695 = MakeAgentInvocationResultAgentInitialization(AgentInvocationOutputParameters{golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1456, result1460, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result1484, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}}})
+
+				case 1:
+					result1660 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))), index*(56+22*4))
+						var variant1648 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option1491 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1491 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1486 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1486 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1485 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1485 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1485 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1485 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1486 = witTypes.Some[golem_core_types.NumericBound](variant1485)
+								default:
+									panic("unreachable")
+								}
+								var option1488 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1488 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1487 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1487 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1487 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1487 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1488 = witTypes.Some[golem_core_types.NumericBound](variant1487)
+								default:
+									panic("unreachable")
+								}
+								var option1490 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1490 = witTypes.None[string]()
+								case 1:
+									value1489 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1490 = witTypes.Some[string](value1489)
+								default:
+									panic("unreachable")
+								}
+
+								option1491 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1486, option1488, option1490})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyS8Type(option1491)
+
+						case 3:
+							var option1498 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1498 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1493 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1493 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1492 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1492 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1492 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1492 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1493 = witTypes.Some[golem_core_types.NumericBound](variant1492)
+								default:
+									panic("unreachable")
+								}
+								var option1495 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1495 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1494 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1494 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1494 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1494 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1495 = witTypes.Some[golem_core_types.NumericBound](variant1494)
+								default:
+									panic("unreachable")
+								}
+								var option1497 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1497 = witTypes.None[string]()
+								case 1:
+									value1496 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1497 = witTypes.Some[string](value1496)
+								default:
+									panic("unreachable")
+								}
+
+								option1498 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1493, option1495, option1497})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyS16Type(option1498)
+
+						case 4:
+							var option1505 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1505 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1500 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1500 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1499 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1499 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1499 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1499 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1500 = witTypes.Some[golem_core_types.NumericBound](variant1499)
+								default:
+									panic("unreachable")
+								}
+								var option1502 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1502 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1501 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1501 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1501 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1501 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1502 = witTypes.Some[golem_core_types.NumericBound](variant1501)
+								default:
+									panic("unreachable")
+								}
+								var option1504 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1504 = witTypes.None[string]()
+								case 1:
+									value1503 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1504 = witTypes.Some[string](value1503)
+								default:
+									panic("unreachable")
+								}
+
+								option1505 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1500, option1502, option1504})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyS32Type(option1505)
+
+						case 5:
+							var option1512 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1512 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1507 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1507 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1506 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1506 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1506 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1506 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1507 = witTypes.Some[golem_core_types.NumericBound](variant1506)
+								default:
+									panic("unreachable")
+								}
+								var option1509 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1509 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1508 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1508 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1508 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1508 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1509 = witTypes.Some[golem_core_types.NumericBound](variant1508)
+								default:
+									panic("unreachable")
+								}
+								var option1511 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1511 = witTypes.None[string]()
+								case 1:
+									value1510 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1511 = witTypes.Some[string](value1510)
+								default:
+									panic("unreachable")
+								}
+
+								option1512 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1507, option1509, option1511})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyS64Type(option1512)
+
+						case 6:
+							var option1519 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1519 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1514 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1514 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1513 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1513 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1513 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1513 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1514 = witTypes.Some[golem_core_types.NumericBound](variant1513)
+								default:
+									panic("unreachable")
+								}
+								var option1516 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1516 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1515 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1515 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1515 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1515 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1516 = witTypes.Some[golem_core_types.NumericBound](variant1515)
+								default:
+									panic("unreachable")
+								}
+								var option1518 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1518 = witTypes.None[string]()
+								case 1:
+									value1517 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1518 = witTypes.Some[string](value1517)
+								default:
+									panic("unreachable")
+								}
+
+								option1519 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1514, option1516, option1518})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyU8Type(option1519)
+
+						case 7:
+							var option1526 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1526 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1521 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1521 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1520 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1520 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1520 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1520 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1521 = witTypes.Some[golem_core_types.NumericBound](variant1520)
+								default:
+									panic("unreachable")
+								}
+								var option1523 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1523 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1522 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1522 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1522 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1522 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1523 = witTypes.Some[golem_core_types.NumericBound](variant1522)
+								default:
+									panic("unreachable")
+								}
+								var option1525 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1525 = witTypes.None[string]()
+								case 1:
+									value1524 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1525 = witTypes.Some[string](value1524)
+								default:
+									panic("unreachable")
+								}
+
+								option1526 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1521, option1523, option1525})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyU16Type(option1526)
+
+						case 8:
+							var option1533 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1533 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1528 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1528 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1527 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1527 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1527 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1527 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1528 = witTypes.Some[golem_core_types.NumericBound](variant1527)
+								default:
+									panic("unreachable")
+								}
+								var option1530 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1530 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1529 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1529 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1529 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1529 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1530 = witTypes.Some[golem_core_types.NumericBound](variant1529)
+								default:
+									panic("unreachable")
+								}
+								var option1532 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1532 = witTypes.None[string]()
+								case 1:
+									value1531 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1532 = witTypes.Some[string](value1531)
+								default:
+									panic("unreachable")
+								}
+
+								option1533 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1528, option1530, option1532})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyU32Type(option1533)
+
+						case 9:
+							var option1540 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1540 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1535 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1535 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1534 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1534 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1534 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1534 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1535 = witTypes.Some[golem_core_types.NumericBound](variant1534)
+								default:
+									panic("unreachable")
+								}
+								var option1537 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1537 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1536 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1536 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1536 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1536 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1537 = witTypes.Some[golem_core_types.NumericBound](variant1536)
+								default:
+									panic("unreachable")
+								}
+								var option1539 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1539 = witTypes.None[string]()
+								case 1:
+									value1538 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1539 = witTypes.Some[string](value1538)
+								default:
+									panic("unreachable")
+								}
+
+								option1540 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1535, option1537, option1539})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyU64Type(option1540)
+
+						case 10:
+							var option1547 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1547 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1542 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1542 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1541 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1541 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1541 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1541 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1542 = witTypes.Some[golem_core_types.NumericBound](variant1541)
+								default:
+									panic("unreachable")
+								}
+								var option1544 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1544 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1543 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1543 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1543 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1543 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1544 = witTypes.Some[golem_core_types.NumericBound](variant1543)
+								default:
+									panic("unreachable")
+								}
+								var option1546 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1546 = witTypes.None[string]()
+								case 1:
+									value1545 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1546 = witTypes.Some[string](value1545)
+								default:
+									panic("unreachable")
+								}
+
+								option1547 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1542, option1544, option1546})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyF32Type(option1547)
+
+						case 11:
+							var option1554 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1554 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1549 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1549 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1548 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1548 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1548 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1548 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1549 = witTypes.Some[golem_core_types.NumericBound](variant1548)
+								default:
+									panic("unreachable")
+								}
+								var option1551 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1551 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1550 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1550 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1550 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1550 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1551 = witTypes.Some[golem_core_types.NumericBound](variant1550)
+								default:
+									panic("unreachable")
+								}
+								var option1553 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1553 = witTypes.None[string]()
+								case 1:
+									value1552 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1553 = witTypes.Some[string](value1552)
+								default:
+									panic("unreachable")
+								}
+
+								option1554 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1549, option1551, option1553})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyF64Type(option1554)
+
+						case 12:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result1567 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value1555 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1557 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option1557 = witTypes.None[string]()
+								case 1:
+									value1556 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option1557 = witTypes.Some[string](value1556)
+								default:
+									panic("unreachable")
+								}
+								result1559 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value1558 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1559 = append(result1559, value1558)
+								}
+
+								result1561 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value1560 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1561 = append(result1561, value1560)
+								}
+
+								var option1563 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option1563 = witTypes.None[string]()
+								case 1:
+									value1562 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option1563 = witTypes.Some[string](value1562)
+								default:
+									panic("unreachable")
+								}
+								var option1566 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option1566 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1565 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant1565 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1565 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1565 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1564 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant1565 = golem_core_types.MakeRoleOther(value1564)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1566 = witTypes.Some[golem_core_types.Role](variant1565)
+								default:
+									panic("unreachable")
+								}
+
+								result1567 = append(result1567, golem_core_types.NamedFieldType{value1555, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1557, result1559, result1561, option1563, option1566}})
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyRecordType(result1567)
+
+						case 15:
+							result1581 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value1568 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1569 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option1569 = witTypes.None[int32]()
+								case 1:
+
+									option1569 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option1571 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option1571 = witTypes.None[string]()
+								case 1:
+									value1570 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option1571 = witTypes.Some[string](value1570)
+								default:
+									panic("unreachable")
+								}
+								result1573 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1572 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1573 = append(result1573, value1572)
+								}
+
+								result1575 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value1574 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1575 = append(result1575, value1574)
+								}
+
+								var option1577 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option1577 = witTypes.None[string]()
+								case 1:
+									value1576 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option1577 = witTypes.Some[string](value1576)
+								default:
+									panic("unreachable")
+								}
+								var option1580 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option1580 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1579 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant1579 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1579 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1579 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1578 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant1579 = golem_core_types.MakeRoleOther(value1578)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1580 = witTypes.Some[golem_core_types.Role](variant1579)
+								default:
+									panic("unreachable")
+								}
+
+								result1581 = append(result1581, golem_core_types.VariantCaseType{value1568, option1569, golem_core_types.MetadataEnvelope{option1571, result1573, result1575, option1577, option1580}})
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyVariantType(result1581)
+
+						case 16:
+							result1583 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1582 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1583 = append(result1583, value1582)
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyEnumType(result1583)
+
+						case 17:
+							result1585 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1584 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1585 = append(result1585, value1584)
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1585)
+
+						case 18:
+							result1586 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1586 = append(result1586, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyTupleType(result1586)
+
+						case 19:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option1587 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1587 = witTypes.None[int32]()
+							case 1:
+
+								option1587 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option1588 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option1588 = witTypes.None[int32]()
+							case 1:
+
+								option1588 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1587, option1588})
+
+						case 24:
+							var option1591 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1591 = witTypes.None[[]string]()
+							case 1:
+								result1590 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1589 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1590 = append(result1590, value1589)
+								}
+
+								option1591 = witTypes.Some[[]string](result1590)
+							default:
+								panic("unreachable")
+							}
+							var option1592 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1592 = witTypes.None[uint32]()
+							case 1:
+
+								option1592 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1593 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1593 = witTypes.None[uint32]()
+							case 1:
+
+								option1593 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1595 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option1595 = witTypes.None[string]()
+							case 1:
+								value1594 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option1595 = witTypes.Some[string](value1594)
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1591, option1592, option1593, option1595})
+
+						case 25:
+							var option1598 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1598 = witTypes.None[[]string]()
+							case 1:
+								result1597 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1596 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1597 = append(result1597, value1596)
+								}
+
+								option1598 = witTypes.Some[[]string](result1597)
+							default:
+								panic("unreachable")
+							}
+							var option1599 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1599 = witTypes.None[uint32]()
+							case 1:
+
+								option1599 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1600 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1600 = witTypes.None[uint32]()
+							case 1:
+
+								option1600 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1598, option1599, option1600})
+
+						case 26:
+							var option1603 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1603 = witTypes.None[[]string]()
+							case 1:
+								result1602 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value1601 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1602 = append(result1602, value1601)
+								}
+
+								option1603 = witTypes.Some[[]string](result1602)
+							default:
+								panic("unreachable")
+							}
+							var option1606 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1606 = witTypes.None[[]string]()
+							case 1:
+								result1605 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1604 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1605 = append(result1605, value1604)
+								}
+
+								option1606 = witTypes.Some[[]string](result1605)
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option1603, option1606})
+
+						case 27:
+							var option1609 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1609 = witTypes.None[[]string]()
+							case 1:
+								result1608 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1607 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1608 = append(result1608, value1607)
+								}
+
+								option1609 = witTypes.Some[[]string](result1608)
+							default:
+								panic("unreachable")
+							}
+							var option1612 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1612 = witTypes.None[[]string]()
+							case 1:
+								result1611 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value1610 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1611 = append(result1611, value1610)
+								}
+
+								option1612 = witTypes.Some[[]string](result1611)
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1609, option1612})
+
+						case 28:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value1613 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result1615 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value1614 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1615 = append(result1615, value1614)
+							}
+
+							var option1617 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1617 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1616 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option1617 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value1616})
+							default:
+								panic("unreachable")
+							}
+							var option1619 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option1619 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1618 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option1619 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value1618})
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1613, result1615, option1617, option1619})
+
+						case 31:
+							result1641 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value1620 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant1629 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value1621 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1629 = golem_core_types.MakeDiscriminatorRulePrefix(value1621)
+
+								case 1:
+									value1622 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1629 = golem_core_types.MakeDiscriminatorRuleSuffix(value1622)
+
+								case 2:
+									value1623 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1629 = golem_core_types.MakeDiscriminatorRuleContains(value1623)
+
+								case 3:
+									value1624 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1629 = golem_core_types.MakeDiscriminatorRuleRegex(value1624)
+
+								case 4:
+									value1625 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option1627 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option1627 = witTypes.None[string]()
+									case 1:
+										value1626 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option1627 = witTypes.Some[string](value1626)
+									default:
+										panic("unreachable")
+									}
+
+									variant1629 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1625, option1627})
+
+								case 5:
+									value1628 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1629 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1628)
+
+								default:
+									panic("unreachable")
+								}
+								var option1631 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option1631 = witTypes.None[string]()
+								case 1:
+									value1630 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option1631 = witTypes.Some[string](value1630)
+								default:
+									panic("unreachable")
+								}
+								result1633 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value1632 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1633 = append(result1633, value1632)
+								}
+
+								result1635 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value1634 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1635 = append(result1635, value1634)
+								}
+
+								var option1637 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option1637 = witTypes.None[string]()
+								case 1:
+									value1636 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option1637 = witTypes.Some[string](value1636)
+								default:
+									panic("unreachable")
+								}
+								var option1640 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option1640 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1639 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant1639 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1639 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1639 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1638 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant1639 = golem_core_types.MakeRoleOther(value1638)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1640 = witTypes.Some[golem_core_types.Role](variant1639)
+								default:
+									panic("unreachable")
+								}
+
+								result1641 = append(result1641, golem_core_types.UnionBranch{value1620, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1629, golem_core_types.MetadataEnvelope{option1631, result1633, result1635, option1637, option1640}})
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1641})
+
+						case 32:
+							var option1643 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1643 = witTypes.None[string]()
+							case 1:
+								value1642 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option1643 = witTypes.Some[string](value1642)
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1643})
+
+						case 33:
+							var option1645 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1645 = witTypes.None[string]()
+							case 1:
+								value1644 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option1645 = witTypes.Some[string](value1644)
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1645})
+
+						case 34:
+							var option1646 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1646 = witTypes.None[int32]()
+							case 1:
+
+								option1646 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyFutureType(option1646)
+
+						case 35:
+							var option1647 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1647 = witTypes.None[int32]()
+							case 1:
+
+								option1647 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1648 = golem_core_types.MakeSchemaTypeBodyStreamType(option1647)
+
+						default:
+							panic("unreachable")
+						}
+						var option1650 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option1650 = witTypes.None[string]()
+						case 1:
+							value1649 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option1650 = witTypes.Some[string](value1649)
+						default:
+							panic("unreachable")
+						}
+						result1652 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value1651 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1652 = append(result1652, value1651)
+						}
+
+						result1654 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value1653 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1654 = append(result1654, value1653)
+						}
+
+						var option1656 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option1656 = witTypes.None[string]()
+						case 1:
+							value1655 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option1656 = witTypes.Some[string](value1655)
+						default:
+							panic("unreachable")
+						}
+						var option1659 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option1659 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant1658 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant1658 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant1658 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant1658 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value1657 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant1658 = golem_core_types.MakeRoleOther(value1657)
+
+							default:
+								panic("unreachable")
+							}
+
+							option1659 = witTypes.Some[golem_core_types.Role](variant1658)
+						default:
+							panic("unreachable")
+						}
+
+						result1660 = append(result1660, golem_core_types.SchemaTypeNode{variant1648, golem_core_types.MetadataEnvelope{option1650, result1652, result1654, option1656, option1659}})
+					}
+
+					result1664 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))), index*(6*4))
+						value1661 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option1663 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option1663 = witTypes.None[string]()
+						case 1:
+							value1662 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option1663 = witTypes.Some[string](value1662)
+						default:
+							panic("unreachable")
+						}
+
+						result1664 = append(result1664, golem_core_types.SchemaTypeDef{value1661, option1663, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result1688 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))))), index*(16+4*4))
+						var variant1687 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value1665 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeStringValue(value1665)
+
+						case 13:
+							result1666 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1666 = append(result1666, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeRecordValue(result1666)
+
+						case 14:
+							var option1667 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option1667 = witTypes.None[int32]()
+							case 1:
+
+								option1667 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1667})
+
+						case 15:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result1668 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result1668 = append(result1668, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1668)
+
+						case 17:
+							result1669 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1669 = append(result1669, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeTupleValue(result1669)
+
+						case 18:
+							result1670 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1670 = append(result1670, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeListValue(result1670)
+
+						case 19:
+							result1671 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1671 = append(result1671, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1671)
+
+						case 20:
+							result1672 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result1672 = append(result1672, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeMapValue(result1672)
+
+						case 21:
+							var option1673 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1673 = witTypes.None[int32]()
+							case 1:
+
+								option1673 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeOptionValue(option1673)
+
+						case 22:
+							var variant1676 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option1674 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1674 = witTypes.None[int32]()
+								case 1:
+
+									option1674 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1676 = golem_core_types.MakeResultValuePayloadOkValue(option1674)
+
+							case 1:
+								var option1675 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1675 = witTypes.None[int32]()
+								case 1:
+
+									option1675 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1676 = golem_core_types.MakeResultValuePayloadErrValue(option1675)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeResultValue(variant1676)
+
+						case 23:
+							value1677 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1679 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1679 = witTypes.None[string]()
+							case 1:
+								value1678 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1679 = witTypes.Some[string](value1678)
+							default:
+								panic("unreachable")
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1677, option1679})
+
+						case 24:
+							value1680 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1682 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1682 = witTypes.None[string]()
+							case 1:
+								value1681 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1682 = witTypes.Some[string](value1681)
+							default:
+								panic("unreachable")
+							}
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1680, option1682})
+
+						case 25:
+							value1683 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1687 = golem_core_types.MakeSchemaValueNodePathValue(value1683)
+
+						case 26:
+							value1684 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeUrlValue(value1684)
+
+						case 27:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value1685 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1685})
+
+						case 30:
+							value1686 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1686, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant1687 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result1688 = append(result1688, variant1687)
+					}
+
+					variant1695 = MakeAgentInvocationResultAgentMethod(AgentInvocationOutputParameters{golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1660, result1664, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result1688, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}}})
+
+				case 2:
+
+					variant1695 = MakeAgentInvocationResultManualUpdate()
+
+				case 3:
+					var option1690 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) {
+					case 0:
+
+						option1690 = witTypes.None[string]()
+					case 1:
+						value1689 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+
+						option1690 = witTypes.Some[string](value1689)
+					default:
+						panic("unreachable")
+					}
+
+					variant1695 = MakeAgentInvocationResultLoadSnapshot(FallibleResultParameters{option1690})
+
+				case 4:
+					value1691 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))
+					value1692 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))
+
+					variant1695 = MakeAgentInvocationResultSaveSnapshot(SaveSnapshotResultParameters{SnapshotData{value1691, value1692}})
+
+				case 5:
+					var option1694 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) {
+					case 0:
+
+						option1694 = witTypes.None[string]()
+					case 1:
+						value1693 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+
+						option1694 = witTypes.Some[string](value1693)
+					default:
+						panic("unreachable")
+					}
+
+					variant1695 = MakeAgentInvocationResultProcessOplogEntries(FallibleResultParameters{option1694})
+
+				default:
+					panic("unreachable")
+				}
+				var option1697 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4)))) {
+				case 0:
+
+					option1697 = witTypes.None[string]()
+				case 1:
+					value1696 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4))))
+
+					option1697 = witTypes.Some[string](value1696)
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryAgentInvocationFinished(AgentInvocationFinishedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, variant1695, option1697, *(*int64)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 12*4))))})
+
+			case 6:
+
+				variant2471 = MakePublicOplogEntrySuspend(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}})
+
+			case 7:
+				value1698 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+				var option1701 witTypes.Option[RetryPolicyState]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))) {
+				case 0:
+
+					option1701 = witTypes.None[RetryPolicyState]()
+				case 1:
+					result1700 := make([]StateNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))), index*16)
+						var variant1699 StateNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1699 = MakeStateNodeCounter(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4))))
+
+						case 1:
+
+							variant1699 = MakeStateNodeTerminal()
+
+						case 2:
+
+							variant1699 = MakeStateNodeWrapper(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						case 3:
+
+							variant1699 = MakeStateNodeCountBox(CountBoxState{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 4:
+
+							variant1699 = MakeStateNodeAndThen(AndThenState{*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) != 0)})
+
+						case 5:
+
+							variant1699 = MakeStateNodePair(PairState{*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						default:
+							panic("unreachable")
+						}
+
+						result1700 = append(result1700, variant1699)
+					}
+
+					option1701 = witTypes.Some[RetryPolicyState](RetryPolicyState{result1700})
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryError(ErrorParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, value1698, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))) != 0), option1701})
+
+			case 8:
+
+				variant2471 = MakePublicOplogEntryNoOp(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}})
+
+			case 9:
+
+				variant2471 = MakePublicOplogEntryJump(JumpParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, OplogRegion{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}})
+
+			case 10:
+
+				variant2471 = MakePublicOplogEntryInterrupted(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}})
+
+			case 11:
+
+				variant2471 = MakePublicOplogEntryExited(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}})
+
+			case 12:
+
+				variant2471 = MakePublicOplogEntryBeginAtomicRegion(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}})
+
+			case 13:
+
+				variant2471 = MakePublicOplogEntryEndAtomicRegion(EndAtomicRegionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))})
+
+			case 14:
+				var variant2146 AgentInvocation
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+				case 0:
+					value1702 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+					result1878 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))))), index*(56+22*4))
+						var variant1866 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option1709 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1709 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1704 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1704 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1703 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1703 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1703 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1703 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1704 = witTypes.Some[golem_core_types.NumericBound](variant1703)
+								default:
+									panic("unreachable")
+								}
+								var option1706 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1706 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1705 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1705 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1705 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1705 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1706 = witTypes.Some[golem_core_types.NumericBound](variant1705)
+								default:
+									panic("unreachable")
+								}
+								var option1708 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1708 = witTypes.None[string]()
+								case 1:
+									value1707 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1708 = witTypes.Some[string](value1707)
+								default:
+									panic("unreachable")
+								}
+
+								option1709 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1704, option1706, option1708})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyS8Type(option1709)
+
+						case 3:
+							var option1716 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1716 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1711 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1711 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1710 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1710 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1710 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1710 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1711 = witTypes.Some[golem_core_types.NumericBound](variant1710)
+								default:
+									panic("unreachable")
+								}
+								var option1713 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1713 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1712 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1712 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1712 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1712 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1713 = witTypes.Some[golem_core_types.NumericBound](variant1712)
+								default:
+									panic("unreachable")
+								}
+								var option1715 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1715 = witTypes.None[string]()
+								case 1:
+									value1714 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1715 = witTypes.Some[string](value1714)
+								default:
+									panic("unreachable")
+								}
+
+								option1716 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1711, option1713, option1715})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyS16Type(option1716)
+
+						case 4:
+							var option1723 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1723 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1718 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1718 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1717 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1717 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1717 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1717 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1718 = witTypes.Some[golem_core_types.NumericBound](variant1717)
+								default:
+									panic("unreachable")
+								}
+								var option1720 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1720 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1719 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1719 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1719 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1719 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1720 = witTypes.Some[golem_core_types.NumericBound](variant1719)
+								default:
+									panic("unreachable")
+								}
+								var option1722 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1722 = witTypes.None[string]()
+								case 1:
+									value1721 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1722 = witTypes.Some[string](value1721)
+								default:
+									panic("unreachable")
+								}
+
+								option1723 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1718, option1720, option1722})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyS32Type(option1723)
+
+						case 5:
+							var option1730 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1730 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1725 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1725 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1724 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1724 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1724 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1724 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1725 = witTypes.Some[golem_core_types.NumericBound](variant1724)
+								default:
+									panic("unreachable")
+								}
+								var option1727 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1727 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1726 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1726 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1726 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1726 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1727 = witTypes.Some[golem_core_types.NumericBound](variant1726)
+								default:
+									panic("unreachable")
+								}
+								var option1729 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1729 = witTypes.None[string]()
+								case 1:
+									value1728 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1729 = witTypes.Some[string](value1728)
+								default:
+									panic("unreachable")
+								}
+
+								option1730 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1725, option1727, option1729})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyS64Type(option1730)
+
+						case 6:
+							var option1737 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1737 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1732 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1732 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1731 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1731 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1731 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1731 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1732 = witTypes.Some[golem_core_types.NumericBound](variant1731)
+								default:
+									panic("unreachable")
+								}
+								var option1734 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1734 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1733 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1733 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1733 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1733 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1734 = witTypes.Some[golem_core_types.NumericBound](variant1733)
+								default:
+									panic("unreachable")
+								}
+								var option1736 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1736 = witTypes.None[string]()
+								case 1:
+									value1735 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1736 = witTypes.Some[string](value1735)
+								default:
+									panic("unreachable")
+								}
+
+								option1737 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1732, option1734, option1736})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyU8Type(option1737)
+
+						case 7:
+							var option1744 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1744 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1739 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1739 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1738 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1738 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1738 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1738 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1739 = witTypes.Some[golem_core_types.NumericBound](variant1738)
+								default:
+									panic("unreachable")
+								}
+								var option1741 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1741 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1740 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1740 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1740 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1740 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1741 = witTypes.Some[golem_core_types.NumericBound](variant1740)
+								default:
+									panic("unreachable")
+								}
+								var option1743 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1743 = witTypes.None[string]()
+								case 1:
+									value1742 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1743 = witTypes.Some[string](value1742)
+								default:
+									panic("unreachable")
+								}
+
+								option1744 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1739, option1741, option1743})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyU16Type(option1744)
+
+						case 8:
+							var option1751 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1751 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1746 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1746 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1745 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1745 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1745 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1745 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1746 = witTypes.Some[golem_core_types.NumericBound](variant1745)
+								default:
+									panic("unreachable")
+								}
+								var option1748 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1748 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1747 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1747 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1747 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1747 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1748 = witTypes.Some[golem_core_types.NumericBound](variant1747)
+								default:
+									panic("unreachable")
+								}
+								var option1750 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1750 = witTypes.None[string]()
+								case 1:
+									value1749 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1750 = witTypes.Some[string](value1749)
+								default:
+									panic("unreachable")
+								}
+
+								option1751 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1746, option1748, option1750})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyU32Type(option1751)
+
+						case 9:
+							var option1758 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1758 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1753 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1753 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1752 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1752 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1752 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1752 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1753 = witTypes.Some[golem_core_types.NumericBound](variant1752)
+								default:
+									panic("unreachable")
+								}
+								var option1755 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1755 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1754 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1754 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1754 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1754 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1755 = witTypes.Some[golem_core_types.NumericBound](variant1754)
+								default:
+									panic("unreachable")
+								}
+								var option1757 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1757 = witTypes.None[string]()
+								case 1:
+									value1756 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1757 = witTypes.Some[string](value1756)
+								default:
+									panic("unreachable")
+								}
+
+								option1758 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1753, option1755, option1757})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyU64Type(option1758)
+
+						case 10:
+							var option1765 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1765 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1760 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1760 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1759 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1759 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1759 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1759 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1760 = witTypes.Some[golem_core_types.NumericBound](variant1759)
+								default:
+									panic("unreachable")
+								}
+								var option1762 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1762 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1761 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1761 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1761 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1761 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1762 = witTypes.Some[golem_core_types.NumericBound](variant1761)
+								default:
+									panic("unreachable")
+								}
+								var option1764 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1764 = witTypes.None[string]()
+								case 1:
+									value1763 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1764 = witTypes.Some[string](value1763)
+								default:
+									panic("unreachable")
+								}
+
+								option1765 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1760, option1762, option1764})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyF32Type(option1765)
+
+						case 11:
+							var option1772 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1772 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1767 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1767 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1766 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1766 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1766 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1766 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1767 = witTypes.Some[golem_core_types.NumericBound](variant1766)
+								default:
+									panic("unreachable")
+								}
+								var option1769 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1769 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1768 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1768 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1768 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1768 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1769 = witTypes.Some[golem_core_types.NumericBound](variant1768)
+								default:
+									panic("unreachable")
+								}
+								var option1771 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1771 = witTypes.None[string]()
+								case 1:
+									value1770 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1771 = witTypes.Some[string](value1770)
+								default:
+									panic("unreachable")
+								}
+
+								option1772 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1767, option1769, option1771})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyF64Type(option1772)
+
+						case 12:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result1785 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value1773 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1775 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option1775 = witTypes.None[string]()
+								case 1:
+									value1774 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option1775 = witTypes.Some[string](value1774)
+								default:
+									panic("unreachable")
+								}
+								result1777 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value1776 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1777 = append(result1777, value1776)
+								}
+
+								result1779 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value1778 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1779 = append(result1779, value1778)
+								}
+
+								var option1781 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option1781 = witTypes.None[string]()
+								case 1:
+									value1780 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option1781 = witTypes.Some[string](value1780)
+								default:
+									panic("unreachable")
+								}
+								var option1784 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option1784 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1783 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant1783 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1783 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1783 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1782 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant1783 = golem_core_types.MakeRoleOther(value1782)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1784 = witTypes.Some[golem_core_types.Role](variant1783)
+								default:
+									panic("unreachable")
+								}
+
+								result1785 = append(result1785, golem_core_types.NamedFieldType{value1773, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1775, result1777, result1779, option1781, option1784}})
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyRecordType(result1785)
+
+						case 15:
+							result1799 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value1786 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1787 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option1787 = witTypes.None[int32]()
+								case 1:
+
+									option1787 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option1789 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option1789 = witTypes.None[string]()
+								case 1:
+									value1788 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option1789 = witTypes.Some[string](value1788)
+								default:
+									panic("unreachable")
+								}
+								result1791 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1790 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1791 = append(result1791, value1790)
+								}
+
+								result1793 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value1792 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1793 = append(result1793, value1792)
+								}
+
+								var option1795 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option1795 = witTypes.None[string]()
+								case 1:
+									value1794 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option1795 = witTypes.Some[string](value1794)
+								default:
+									panic("unreachable")
+								}
+								var option1798 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option1798 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1797 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant1797 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1797 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1797 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1796 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant1797 = golem_core_types.MakeRoleOther(value1796)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1798 = witTypes.Some[golem_core_types.Role](variant1797)
+								default:
+									panic("unreachable")
+								}
+
+								result1799 = append(result1799, golem_core_types.VariantCaseType{value1786, option1787, golem_core_types.MetadataEnvelope{option1789, result1791, result1793, option1795, option1798}})
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyVariantType(result1799)
+
+						case 16:
+							result1801 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1800 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1801 = append(result1801, value1800)
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyEnumType(result1801)
+
+						case 17:
+							result1803 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value1802 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1803 = append(result1803, value1802)
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1803)
+
+						case 18:
+							result1804 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1804 = append(result1804, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyTupleType(result1804)
+
+						case 19:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option1805 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1805 = witTypes.None[int32]()
+							case 1:
+
+								option1805 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option1806 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option1806 = witTypes.None[int32]()
+							case 1:
+
+								option1806 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1805, option1806})
+
+						case 24:
+							var option1809 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1809 = witTypes.None[[]string]()
+							case 1:
+								result1808 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1807 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1808 = append(result1808, value1807)
+								}
+
+								option1809 = witTypes.Some[[]string](result1808)
+							default:
+								panic("unreachable")
+							}
+							var option1810 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1810 = witTypes.None[uint32]()
+							case 1:
+
+								option1810 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1811 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1811 = witTypes.None[uint32]()
+							case 1:
+
+								option1811 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1813 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option1813 = witTypes.None[string]()
+							case 1:
+								value1812 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option1813 = witTypes.Some[string](value1812)
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1809, option1810, option1811, option1813})
+
+						case 25:
+							var option1816 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1816 = witTypes.None[[]string]()
+							case 1:
+								result1815 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1814 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1815 = append(result1815, value1814)
+								}
+
+								option1816 = witTypes.Some[[]string](result1815)
+							default:
+								panic("unreachable")
+							}
+							var option1817 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1817 = witTypes.None[uint32]()
+							case 1:
+
+								option1817 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option1818 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option1818 = witTypes.None[uint32]()
+							case 1:
+
+								option1818 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1816, option1817, option1818})
+
+						case 26:
+							var option1821 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1821 = witTypes.None[[]string]()
+							case 1:
+								result1820 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value1819 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1820 = append(result1820, value1819)
+								}
+
+								option1821 = witTypes.Some[[]string](result1820)
+							default:
+								panic("unreachable")
+							}
+							var option1824 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1824 = witTypes.None[[]string]()
+							case 1:
+								result1823 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value1822 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1823 = append(result1823, value1822)
+								}
+
+								option1824 = witTypes.Some[[]string](result1823)
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option1821, option1824})
+
+						case 27:
+							var option1827 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1827 = witTypes.None[[]string]()
+							case 1:
+								result1826 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value1825 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1826 = append(result1826, value1825)
+								}
+
+								option1827 = witTypes.Some[[]string](result1826)
+							default:
+								panic("unreachable")
+							}
+							var option1830 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option1830 = witTypes.None[[]string]()
+							case 1:
+								result1829 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value1828 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1829 = append(result1829, value1828)
+								}
+
+								option1830 = witTypes.Some[[]string](result1829)
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1827, option1830})
+
+						case 28:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value1831 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result1833 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value1832 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result1833 = append(result1833, value1832)
+							}
+
+							var option1835 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option1835 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1834 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option1835 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value1834})
+							default:
+								panic("unreachable")
+							}
+							var option1837 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option1837 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value1836 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option1837 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value1836})
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1831, result1833, option1835, option1837})
+
+						case 31:
+							result1859 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value1838 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant1847 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value1839 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1847 = golem_core_types.MakeDiscriminatorRulePrefix(value1839)
+
+								case 1:
+									value1840 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1847 = golem_core_types.MakeDiscriminatorRuleSuffix(value1840)
+
+								case 2:
+									value1841 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1847 = golem_core_types.MakeDiscriminatorRuleContains(value1841)
+
+								case 3:
+									value1842 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1847 = golem_core_types.MakeDiscriminatorRuleRegex(value1842)
+
+								case 4:
+									value1843 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option1845 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option1845 = witTypes.None[string]()
+									case 1:
+										value1844 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option1845 = witTypes.Some[string](value1844)
+									default:
+										panic("unreachable")
+									}
+
+									variant1847 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1843, option1845})
+
+								case 5:
+									value1846 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant1847 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1846)
+
+								default:
+									panic("unreachable")
+								}
+								var option1849 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option1849 = witTypes.None[string]()
+								case 1:
+									value1848 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option1849 = witTypes.Some[string](value1848)
+								default:
+									panic("unreachable")
+								}
+								result1851 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value1850 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1851 = append(result1851, value1850)
+								}
+
+								result1853 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value1852 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1853 = append(result1853, value1852)
+								}
+
+								var option1855 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option1855 = witTypes.None[string]()
+								case 1:
+									value1854 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option1855 = witTypes.Some[string](value1854)
+								default:
+									panic("unreachable")
+								}
+								var option1858 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option1858 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant1857 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant1857 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant1857 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant1857 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value1856 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant1857 = golem_core_types.MakeRoleOther(value1856)
+
+									default:
+										panic("unreachable")
+									}
+
+									option1858 = witTypes.Some[golem_core_types.Role](variant1857)
+								default:
+									panic("unreachable")
+								}
+
+								result1859 = append(result1859, golem_core_types.UnionBranch{value1838, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1847, golem_core_types.MetadataEnvelope{option1849, result1851, result1853, option1855, option1858}})
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1859})
+
+						case 32:
+							var option1861 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option1861 = witTypes.None[string]()
+							case 1:
+								value1860 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option1861 = witTypes.Some[string](value1860)
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1861})
+
+						case 33:
+							var option1863 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1863 = witTypes.None[string]()
+							case 1:
+								value1862 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option1863 = witTypes.Some[string](value1862)
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1863})
+
+						case 34:
+							var option1864 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1864 = witTypes.None[int32]()
+							case 1:
+
+								option1864 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyFutureType(option1864)
+
+						case 35:
+							var option1865 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1865 = witTypes.None[int32]()
+							case 1:
+
+								option1865 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1866 = golem_core_types.MakeSchemaTypeBodyStreamType(option1865)
+
+						default:
+							panic("unreachable")
+						}
+						var option1868 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option1868 = witTypes.None[string]()
+						case 1:
+							value1867 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option1868 = witTypes.Some[string](value1867)
+						default:
+							panic("unreachable")
+						}
+						result1870 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value1869 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1870 = append(result1870, value1869)
+						}
+
+						result1872 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value1871 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result1872 = append(result1872, value1871)
+						}
+
+						var option1874 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option1874 = witTypes.None[string]()
+						case 1:
+							value1873 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option1874 = witTypes.Some[string](value1873)
+						default:
+							panic("unreachable")
+						}
+						var option1877 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option1877 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant1876 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant1876 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant1876 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant1876 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value1875 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant1876 = golem_core_types.MakeRoleOther(value1875)
+
+							default:
+								panic("unreachable")
+							}
+
+							option1877 = witTypes.Some[golem_core_types.Role](variant1876)
+						default:
+							panic("unreachable")
+						}
+
+						result1878 = append(result1878, golem_core_types.SchemaTypeNode{variant1866, golem_core_types.MetadataEnvelope{option1868, result1870, result1872, option1874, option1877}})
+					}
+
+					result1882 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))), index*(6*4))
+						value1879 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option1881 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option1881 = witTypes.None[string]()
+						case 1:
+							value1880 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option1881 = witTypes.Some[string](value1880)
+						default:
+							panic("unreachable")
+						}
+
+						result1882 = append(result1882, golem_core_types.SchemaTypeDef{value1879, option1881, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result1906 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 7*4))))), index*(16+4*4))
+						var variant1905 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value1883 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeStringValue(value1883)
+
+						case 13:
+							result1884 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1884 = append(result1884, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeRecordValue(result1884)
+
+						case 14:
+							var option1885 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option1885 = witTypes.None[int32]()
+							case 1:
+
+								option1885 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1885})
+
+						case 15:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result1886 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result1886 = append(result1886, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1886)
+
+						case 17:
+							result1887 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1887 = append(result1887, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeTupleValue(result1887)
+
+						case 18:
+							result1888 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1888 = append(result1888, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeListValue(result1888)
+
+						case 19:
+							result1889 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result1889 = append(result1889, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1889)
+
+						case 20:
+							result1890 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result1890 = append(result1890, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeMapValue(result1890)
+
+						case 21:
+							var option1891 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1891 = witTypes.None[int32]()
+							case 1:
+
+								option1891 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeOptionValue(option1891)
+
+						case 22:
+							var variant1894 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option1892 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1892 = witTypes.None[int32]()
+								case 1:
+
+									option1892 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1894 = golem_core_types.MakeResultValuePayloadOkValue(option1892)
+
+							case 1:
+								var option1893 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option1893 = witTypes.None[int32]()
+								case 1:
+
+									option1893 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant1894 = golem_core_types.MakeResultValuePayloadErrValue(option1893)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeResultValue(variant1894)
+
+						case 23:
+							value1895 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1897 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1897 = witTypes.None[string]()
+							case 1:
+								value1896 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1897 = witTypes.Some[string](value1896)
+							default:
+								panic("unreachable")
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1895, option1897})
+
+						case 24:
+							value1898 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option1900 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option1900 = witTypes.None[string]()
+							case 1:
+								value1899 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option1900 = witTypes.Some[string](value1899)
+							default:
+								panic("unreachable")
+							}
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1898, option1900})
+
+						case 25:
+							value1901 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1905 = golem_core_types.MakeSchemaValueNodePathValue(value1901)
+
+						case 26:
+							value1902 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeUrlValue(value1902)
+
+						case 27:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value1903 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1903})
+
+						case 30:
+							value1904 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1904, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant1905 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result1906 = append(result1906, variant1905)
+					}
+
+					value1907 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 11*4))))
+					result1909 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 13*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 13*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 12*4))))), index*(2*4))
+						value1908 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result1909 = append(result1909, value1908)
+					}
+
+					result1921 := make([][]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 15*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 15*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 14*4))))), index*(2*4))
+						result1920 := make([]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*(56+6*4))
+							var variant1919 SpanData
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value1910 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var option1912 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) {
+								case 0:
+
+									option1912 = witTypes.None[string]()
+								case 1:
+									value1911 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+									option1912 = witTypes.Some[string](value1911)
+								default:
+									panic("unreachable")
+								}
+								var option1913 witTypes.Option[uint64]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) {
+								case 0:
+
+									option1913 = witTypes.None[uint64]()
+								case 1:
+
+									option1913 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))))
+								default:
+									panic("unreachable")
+								}
+								result1917 := make([]golem_api_context.Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))), index*(5*4))
+									value1914 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+									var variant1916 golem_api_context.AttributeValue
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+									case 0:
+										value1915 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+										variant1916 = golem_api_context.MakeAttributeValueString(value1915)
+
+									default:
+										panic("unreachable")
+									}
+
+									result1917 = append(result1917, golem_api_context.Attribute{value1914, variant1916})
+								}
+
+								variant1919 = MakeSpanDataLocalSpan(LocalSpanData{value1910, wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))}, option1912, option1913, result1917, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)})
+
+							case 1:
+								value1918 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant1919 = MakeSpanDataExternalSpan(ExternalSpanData{value1918})
+
+							default:
+								panic("unreachable")
+							}
+
+							result1920 = append(result1920, variant1919)
+						}
+
+						result1921 = append(result1921, result1920)
+					}
+
+					variant2146 = MakeAgentInvocationAgentInitialization(AgentInitializationParameters{value1702, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1878, result1882, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4)))}, golem_core_types.SchemaValueTree{result1906, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 9*4)))}}, value1907, result1909, result1921})
+
+				case 1:
+					value1922 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+					value1923 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))))
+					result2099 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))), index*(56+22*4))
+						var variant2087 golem_core_types.SchemaTypeBody
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 1:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+						case 2:
+							var option1930 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1930 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1925 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1925 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1924 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1924 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1924 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1924 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1925 = witTypes.Some[golem_core_types.NumericBound](variant1924)
+								default:
+									panic("unreachable")
+								}
+								var option1927 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1927 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1926 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1926 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1926 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1926 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1927 = witTypes.Some[golem_core_types.NumericBound](variant1926)
+								default:
+									panic("unreachable")
+								}
+								var option1929 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1929 = witTypes.None[string]()
+								case 1:
+									value1928 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1929 = witTypes.Some[string](value1928)
+								default:
+									panic("unreachable")
+								}
+
+								option1930 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1925, option1927, option1929})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyS8Type(option1930)
+
+						case 3:
+							var option1937 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1937 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1932 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1932 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1931 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1931 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1931 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1931 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1932 = witTypes.Some[golem_core_types.NumericBound](variant1931)
+								default:
+									panic("unreachable")
+								}
+								var option1934 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1934 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1933 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1933 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1933 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1933 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1934 = witTypes.Some[golem_core_types.NumericBound](variant1933)
+								default:
+									panic("unreachable")
+								}
+								var option1936 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1936 = witTypes.None[string]()
+								case 1:
+									value1935 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1936 = witTypes.Some[string](value1935)
+								default:
+									panic("unreachable")
+								}
+
+								option1937 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1932, option1934, option1936})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyS16Type(option1937)
+
+						case 4:
+							var option1944 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1944 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1939 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1939 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1938 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1938 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1938 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1938 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1939 = witTypes.Some[golem_core_types.NumericBound](variant1938)
+								default:
+									panic("unreachable")
+								}
+								var option1941 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1941 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1940 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1940 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1940 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1940 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1941 = witTypes.Some[golem_core_types.NumericBound](variant1940)
+								default:
+									panic("unreachable")
+								}
+								var option1943 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1943 = witTypes.None[string]()
+								case 1:
+									value1942 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1943 = witTypes.Some[string](value1942)
+								default:
+									panic("unreachable")
+								}
+
+								option1944 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1939, option1941, option1943})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyS32Type(option1944)
+
+						case 5:
+							var option1951 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1951 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1946 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1946 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1945 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1945 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1945 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1945 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1946 = witTypes.Some[golem_core_types.NumericBound](variant1945)
+								default:
+									panic("unreachable")
+								}
+								var option1948 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1948 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1947 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1947 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1947 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1947 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1948 = witTypes.Some[golem_core_types.NumericBound](variant1947)
+								default:
+									panic("unreachable")
+								}
+								var option1950 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1950 = witTypes.None[string]()
+								case 1:
+									value1949 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1950 = witTypes.Some[string](value1949)
+								default:
+									panic("unreachable")
+								}
+
+								option1951 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1946, option1948, option1950})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyS64Type(option1951)
+
+						case 6:
+							var option1958 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1958 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1953 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1953 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1952 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1952 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1952 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1952 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1953 = witTypes.Some[golem_core_types.NumericBound](variant1952)
+								default:
+									panic("unreachable")
+								}
+								var option1955 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1955 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1954 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1954 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1954 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1954 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1955 = witTypes.Some[golem_core_types.NumericBound](variant1954)
+								default:
+									panic("unreachable")
+								}
+								var option1957 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1957 = witTypes.None[string]()
+								case 1:
+									value1956 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1957 = witTypes.Some[string](value1956)
+								default:
+									panic("unreachable")
+								}
+
+								option1958 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1953, option1955, option1957})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyU8Type(option1958)
+
+						case 7:
+							var option1965 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1965 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1960 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1960 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1959 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1959 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1959 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1959 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1960 = witTypes.Some[golem_core_types.NumericBound](variant1959)
+								default:
+									panic("unreachable")
+								}
+								var option1962 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1962 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1961 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1961 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1961 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1961 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1962 = witTypes.Some[golem_core_types.NumericBound](variant1961)
+								default:
+									panic("unreachable")
+								}
+								var option1964 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1964 = witTypes.None[string]()
+								case 1:
+									value1963 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1964 = witTypes.Some[string](value1963)
+								default:
+									panic("unreachable")
+								}
+
+								option1965 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1960, option1962, option1964})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyU16Type(option1965)
+
+						case 8:
+							var option1972 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1972 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1967 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1967 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1966 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1966 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1966 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1966 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1967 = witTypes.Some[golem_core_types.NumericBound](variant1966)
+								default:
+									panic("unreachable")
+								}
+								var option1969 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1969 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1968 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1968 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1968 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1968 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1969 = witTypes.Some[golem_core_types.NumericBound](variant1968)
+								default:
+									panic("unreachable")
+								}
+								var option1971 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1971 = witTypes.None[string]()
+								case 1:
+									value1970 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1971 = witTypes.Some[string](value1970)
+								default:
+									panic("unreachable")
+								}
+
+								option1972 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1967, option1969, option1971})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyU32Type(option1972)
+
+						case 9:
+							var option1979 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1979 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1974 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1974 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1973 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1973 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1973 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1973 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1974 = witTypes.Some[golem_core_types.NumericBound](variant1973)
+								default:
+									panic("unreachable")
+								}
+								var option1976 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1976 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1975 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1975 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1975 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1975 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1976 = witTypes.Some[golem_core_types.NumericBound](variant1975)
+								default:
+									panic("unreachable")
+								}
+								var option1978 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1978 = witTypes.None[string]()
+								case 1:
+									value1977 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1978 = witTypes.Some[string](value1977)
+								default:
+									panic("unreachable")
+								}
+
+								option1979 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1974, option1976, option1978})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyU64Type(option1979)
+
+						case 10:
+							var option1986 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1986 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1981 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1981 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1980 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1980 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1980 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1980 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1981 = witTypes.Some[golem_core_types.NumericBound](variant1980)
+								default:
+									panic("unreachable")
+								}
+								var option1983 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1983 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1982 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1982 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1982 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1982 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1983 = witTypes.Some[golem_core_types.NumericBound](variant1982)
+								default:
+									panic("unreachable")
+								}
+								var option1985 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1985 = witTypes.None[string]()
+								case 1:
+									value1984 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1985 = witTypes.Some[string](value1984)
+								default:
+									panic("unreachable")
+								}
+
+								option1986 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1981, option1983, option1985})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyF32Type(option1986)
+
+						case 11:
+							var option1993 witTypes.Option[golem_core_types.NumericRestrictions]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option1993 = witTypes.None[golem_core_types.NumericRestrictions]()
+							case 1:
+								var option1988 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+								case 0:
+
+									option1988 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1987 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+									case 0:
+
+										variant1987 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+									case 1:
+
+										variant1987 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									case 2:
+
+										variant1987 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1988 = witTypes.Some[golem_core_types.NumericBound](variant1987)
+								default:
+									panic("unreachable")
+								}
+								var option1990 witTypes.Option[golem_core_types.NumericBound]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+								case 0:
+
+									option1990 = witTypes.None[golem_core_types.NumericBound]()
+								case 1:
+									var variant1989 golem_core_types.NumericBound
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+									case 0:
+
+										variant1989 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+									case 1:
+
+										variant1989 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									case 2:
+
+										variant1989 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+									default:
+										panic("unreachable")
+									}
+
+									option1990 = witTypes.Some[golem_core_types.NumericBound](variant1989)
+								default:
+									panic("unreachable")
+								}
+								var option1992 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+								case 0:
+
+									option1992 = witTypes.None[string]()
+								case 1:
+									value1991 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+									option1992 = witTypes.Some[string](value1991)
+								default:
+									panic("unreachable")
+								}
+
+								option1993 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1988, option1990, option1992})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyF64Type(option1993)
+
+						case 12:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+						case 13:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+						case 14:
+							result2006 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+								value1994 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option1996 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+
+									option1996 = witTypes.None[string]()
+								case 1:
+									value1995 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									option1996 = witTypes.Some[string](value1995)
+								default:
+									panic("unreachable")
+								}
+								result1998 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+									value1997 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result1998 = append(result1998, value1997)
+								}
+
+								result2000 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+									value1999 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2000 = append(result2000, value1999)
+								}
+
+								var option2002 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+								case 0:
+
+									option2002 = witTypes.None[string]()
+								case 1:
+									value2001 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+									option2002 = witTypes.Some[string](value2001)
+								default:
+									panic("unreachable")
+								}
+								var option2005 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+								case 0:
+
+									option2005 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant2004 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+									case 0:
+
+										variant2004 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant2004 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant2004 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value2003 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+										variant2004 = golem_core_types.MakeRoleOther(value2003)
+
+									default:
+										panic("unreachable")
+									}
+
+									option2005 = witTypes.Some[golem_core_types.Role](variant2004)
+								default:
+									panic("unreachable")
+								}
+
+								result2006 = append(result2006, golem_core_types.NamedFieldType{value1994, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1996, result1998, result2000, option2002, option2005}})
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyRecordType(result2006)
+
+						case 15:
+							result2020 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+								value2007 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var option2008 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+								case 0:
+
+									option2008 = witTypes.None[int32]()
+								case 1:
+
+									option2008 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+								default:
+									panic("unreachable")
+								}
+								var option2010 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+
+									option2010 = witTypes.None[string]()
+								case 1:
+									value2009 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+									option2010 = witTypes.Some[string](value2009)
+								default:
+									panic("unreachable")
+								}
+								result2012 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value2011 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2012 = append(result2012, value2011)
+								}
+
+								result2014 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+									value2013 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2014 = append(result2014, value2013)
+								}
+
+								var option2016 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+								case 0:
+
+									option2016 = witTypes.None[string]()
+								case 1:
+									value2015 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+									option2016 = witTypes.Some[string](value2015)
+								default:
+									panic("unreachable")
+								}
+								var option2019 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+								case 0:
+
+									option2019 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant2018 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+									case 0:
+
+										variant2018 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant2018 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant2018 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value2017 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+										variant2018 = golem_core_types.MakeRoleOther(value2017)
+
+									default:
+										panic("unreachable")
+									}
+
+									option2019 = witTypes.Some[golem_core_types.Role](variant2018)
+								default:
+									panic("unreachable")
+								}
+
+								result2020 = append(result2020, golem_core_types.VariantCaseType{value2007, option2008, golem_core_types.MetadataEnvelope{option2010, result2012, result2014, option2016, option2019}})
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyVariantType(result2020)
+
+						case 16:
+							result2022 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value2021 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2022 = append(result2022, value2021)
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyEnumType(result2022)
+
+						case 17:
+							result2024 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+								value2023 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2024 = append(result2024, value2023)
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyFlagsType(result2024)
+
+						case 18:
+							result2025 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2025 = append(result2025, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyTupleType(result2025)
+
+						case 19:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 20:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+						case 21:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+						case 22:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 23:
+							var option2026 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2026 = witTypes.None[int32]()
+							case 1:
+
+								option2026 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+							var option2027 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2027 = witTypes.None[int32]()
+							case 1:
+
+								option2027 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option2026, option2027})
+
+						case 24:
+							var option2030 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2030 = witTypes.None[[]string]()
+							case 1:
+								result2029 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value2028 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2029 = append(result2029, value2028)
+								}
+
+								option2030 = witTypes.Some[[]string](result2029)
+							default:
+								panic("unreachable")
+							}
+							var option2031 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option2031 = witTypes.None[uint32]()
+							case 1:
+
+								option2031 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option2032 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option2032 = witTypes.None[uint32]()
+							case 1:
+
+								option2032 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option2034 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+							case 0:
+
+								option2034 = witTypes.None[string]()
+							case 1:
+								value2033 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+								option2034 = witTypes.Some[string](value2033)
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option2030, option2031, option2032, option2034})
+
+						case 25:
+							var option2037 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2037 = witTypes.None[[]string]()
+							case 1:
+								result2036 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value2035 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2036 = append(result2036, value2035)
+								}
+
+								option2037 = witTypes.Some[[]string](result2036)
+							default:
+								panic("unreachable")
+							}
+							var option2038 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option2038 = witTypes.None[uint32]()
+							case 1:
+
+								option2038 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+							var option2039 witTypes.Option[uint32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+							case 0:
+
+								option2039 = witTypes.None[uint32]()
+							case 1:
+
+								option2039 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option2037, option2038, option2039})
+
+						case 26:
+							var option2042 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option2042 = witTypes.None[[]string]()
+							case 1:
+								result2041 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+									value2040 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2041 = append(result2041, value2040)
+								}
+
+								option2042 = witTypes.Some[[]string](result2041)
+							default:
+								panic("unreachable")
+							}
+							var option2045 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option2045 = witTypes.None[[]string]()
+							case 1:
+								result2044 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+									value2043 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2044 = append(result2044, value2043)
+								}
+
+								option2045 = witTypes.Some[[]string](result2044)
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option2042, option2045})
+
+						case 27:
+							var option2048 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2048 = witTypes.None[[]string]()
+							case 1:
+								result2047 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+									value2046 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2047 = append(result2047, value2046)
+								}
+
+								option2048 = witTypes.Some[[]string](result2047)
+							default:
+								panic("unreachable")
+							}
+							var option2051 witTypes.Option[[]string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+							case 0:
+
+								option2051 = witTypes.None[[]string]()
+							case 1:
+								result2050 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+									value2049 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2050 = append(result2050, value2049)
+								}
+
+								option2051 = witTypes.Some[[]string](result2050)
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option2048, option2051})
+
+						case 28:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+						case 29:
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+						case 30:
+							value2052 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							result2054 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value2053 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2054 = append(result2054, value2053)
+							}
+
+							var option2056 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+							case 0:
+
+								option2056 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value2055 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+								option2056 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value2055})
+							default:
+								panic("unreachable")
+							}
+							var option2058 witTypes.Option[golem_core_types.QuantityValue]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+							case 0:
+
+								option2058 = witTypes.None[golem_core_types.QuantityValue]()
+							case 1:
+								value2057 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+								option2058 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value2057})
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value2052, result2054, option2056, option2058})
+
+						case 31:
+							result2080 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+								value2059 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+								var variant2068 golem_core_types.DiscriminatorRule
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+								case 0:
+									value2060 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2068 = golem_core_types.MakeDiscriminatorRulePrefix(value2060)
+
+								case 1:
+									value2061 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2068 = golem_core_types.MakeDiscriminatorRuleSuffix(value2061)
+
+								case 2:
+									value2062 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2068 = golem_core_types.MakeDiscriminatorRuleContains(value2062)
+
+								case 3:
+									value2063 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2068 = golem_core_types.MakeDiscriminatorRuleRegex(value2063)
+
+								case 4:
+									value2064 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+									var option2066 witTypes.Option[string]
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+									case 0:
+
+										option2066 = witTypes.None[string]()
+									case 1:
+										value2065 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+										option2066 = witTypes.Some[string](value2065)
+									default:
+										panic("unreachable")
+									}
+
+									variant2068 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value2064, option2066})
+
+								case 5:
+									value2067 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+									variant2068 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value2067)
+
+								default:
+									panic("unreachable")
+								}
+								var option2070 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+								case 0:
+
+									option2070 = witTypes.None[string]()
+								case 1:
+									value2069 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+									option2070 = witTypes.Some[string](value2069)
+								default:
+									panic("unreachable")
+								}
+								result2072 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+									value2071 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2072 = append(result2072, value2071)
+								}
+
+								result2074 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+									value2073 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+									result2074 = append(result2074, value2073)
+								}
+
+								var option2076 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+								case 0:
+
+									option2076 = witTypes.None[string]()
+								case 1:
+									value2075 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+									option2076 = witTypes.Some[string](value2075)
+								default:
+									panic("unreachable")
+								}
+								var option2079 witTypes.Option[golem_core_types.Role]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+								case 0:
+
+									option2079 = witTypes.None[golem_core_types.Role]()
+								case 1:
+									var variant2078 golem_core_types.Role
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+									case 0:
+
+										variant2078 = golem_core_types.MakeRoleMultimodal()
+
+									case 1:
+
+										variant2078 = golem_core_types.MakeRoleUnstructuredText()
+
+									case 2:
+
+										variant2078 = golem_core_types.MakeRoleUnstructuredBinary()
+
+									case 3:
+										value2077 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+										variant2078 = golem_core_types.MakeRoleOther(value2077)
+
+									default:
+										panic("unreachable")
+									}
+
+									option2079 = witTypes.Some[golem_core_types.Role](variant2078)
+								default:
+									panic("unreachable")
+								}
+
+								result2080 = append(result2080, golem_core_types.UnionBranch{value2059, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant2068, golem_core_types.MetadataEnvelope{option2070, result2072, result2074, option2076, option2079}})
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result2080})
+
+						case 32:
+							var option2082 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+							case 0:
+
+								option2082 = witTypes.None[string]()
+							case 1:
+								value2081 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								option2082 = witTypes.Some[string](value2081)
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option2082})
+
+						case 33:
+							var option2084 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2084 = witTypes.None[string]()
+							case 1:
+								value2083 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+								option2084 = witTypes.Some[string](value2083)
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option2084})
+
+						case 34:
+							var option2085 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2085 = witTypes.None[int32]()
+							case 1:
+
+								option2085 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyFutureType(option2085)
+
+						case 35:
+							var option2086 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2086 = witTypes.None[int32]()
+							case 1:
+
+								option2086 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2087 = golem_core_types.MakeSchemaTypeBodyStreamType(option2086)
+
+						default:
+							panic("unreachable")
+						}
+						var option2089 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+						case 0:
+
+							option2089 = witTypes.None[string]()
+						case 1:
+							value2088 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+							option2089 = witTypes.Some[string](value2088)
+						default:
+							panic("unreachable")
+						}
+						result2091 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+							value2090 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2091 = append(result2091, value2090)
+						}
+
+						result2093 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+							value2092 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2093 = append(result2093, value2092)
+						}
+
+						var option2095 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+						case 0:
+
+							option2095 = witTypes.None[string]()
+						case 1:
+							value2094 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+							option2095 = witTypes.Some[string](value2094)
+						default:
+							panic("unreachable")
+						}
+						var option2098 witTypes.Option[golem_core_types.Role]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+						case 0:
+
+							option2098 = witTypes.None[golem_core_types.Role]()
+						case 1:
+							var variant2097 golem_core_types.Role
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+							case 0:
+
+								variant2097 = golem_core_types.MakeRoleMultimodal()
+
+							case 1:
+
+								variant2097 = golem_core_types.MakeRoleUnstructuredText()
+
+							case 2:
+
+								variant2097 = golem_core_types.MakeRoleUnstructuredBinary()
+
+							case 3:
+								value2096 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+								variant2097 = golem_core_types.MakeRoleOther(value2096)
+
+							default:
+								panic("unreachable")
+							}
+
+							option2098 = witTypes.Some[golem_core_types.Role](variant2097)
+						default:
+							panic("unreachable")
+						}
+
+						result2099 = append(result2099, golem_core_types.SchemaTypeNode{variant2087, golem_core_types.MetadataEnvelope{option2089, result2091, result2093, option2095, option2098}})
+					}
+
+					result2103 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 7*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 7*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))))), index*(6*4))
+						value2100 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						var option2102 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+						case 0:
+
+							option2102 = witTypes.None[string]()
+						case 1:
+							value2101 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+							option2102 = witTypes.Some[string](value2101)
+						default:
+							panic("unreachable")
+						}
+
+						result2103 = append(result2103, golem_core_types.SchemaTypeDef{value2100, option2102, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+					}
+
+					result2127 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 10*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 10*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 9*4))))), index*(16+4*4))
+						var variant2126 golem_core_types.SchemaValueNode
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+						case 0:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+						case 1:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 2:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 3:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 4:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 5:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 6:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+						case 7:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 8:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 9:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 10:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+						case 11:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 12:
+							value2104 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeStringValue(value2104)
+
+						case 13:
+							result2105 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2105 = append(result2105, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeRecordValue(result2105)
+
+						case 14:
+							var option2106 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option2106 = witTypes.None[int32]()
+							case 1:
+
+								option2106 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option2106})
+
+						case 15:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+						case 16:
+							result2107 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+								result2107 = append(result2107, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeFlagsValue(result2107)
+
+						case 17:
+							result2108 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2108 = append(result2108, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeTupleValue(result2108)
+
+						case 18:
+							result2109 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2109 = append(result2109, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeListValue(result2109)
+
+						case 19:
+							result2110 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+								result2110 = append(result2110, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeFixedListValue(result2110)
+
+						case 20:
+							result2111 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+								result2111 = append(result2111, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeMapValue(result2111)
+
+						case 21:
+							var option2112 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+
+								option2112 = witTypes.None[int32]()
+							case 1:
+
+								option2112 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeOptionValue(option2112)
+
+						case 22:
+							var variant2115 golem_core_types.ResultValuePayload
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+							case 0:
+								var option2113 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option2113 = witTypes.None[int32]()
+								case 1:
+
+									option2113 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant2115 = golem_core_types.MakeResultValuePayloadOkValue(option2113)
+
+							case 1:
+								var option2114 witTypes.Option[int32]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+								case 0:
+
+									option2114 = witTypes.None[int32]()
+								case 1:
+
+									option2114 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+								default:
+									panic("unreachable")
+								}
+
+								variant2115 = golem_core_types.MakeResultValuePayloadErrValue(option2114)
+
+							default:
+								panic("unreachable")
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeResultValue(variant2115)
+
+						case 23:
+							value2116 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option2118 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option2118 = witTypes.None[string]()
+							case 1:
+								value2117 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option2118 = witTypes.Some[string](value2117)
+							default:
+								panic("unreachable")
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value2116, option2118})
+
+						case 24:
+							value2119 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+							var option2121 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option2121 = witTypes.None[string]()
+							case 1:
+								value2120 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option2121 = witTypes.Some[string](value2120)
+							default:
+								panic("unreachable")
+							}
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value2119, option2121})
+
+						case 25:
+							value2122 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2126 = golem_core_types.MakeSchemaValueNodePathValue(value2122)
+
+						case 26:
+							value2123 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeUrlValue(value2123)
+
+						case 27:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+						case 28:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+						case 29:
+							value2124 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2124})
+
+						case 30:
+							value2125 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value2125, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+						case 31:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						case 32:
+
+							variant2126 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+						default:
+							panic("unreachable")
+						}
+
+						result2127 = append(result2127, variant2126)
+					}
+
+					value2128 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 12*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 13*4))))
+					result2130 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 15*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 15*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 14*4))))), index*(2*4))
+						value2129 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result2130 = append(result2130, value2129)
+					}
+
+					result2142 := make([][]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 17*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 17*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 16*4))))), index*(2*4))
+						result2141 := make([]SpanData, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*(56+6*4))
+							var variant2140 SpanData
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value2131 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var option2133 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) {
+								case 0:
+
+									option2133 = witTypes.None[string]()
+								case 1:
+									value2132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))))
+
+									option2133 = witTypes.Some[string](value2132)
+								default:
+									panic("unreachable")
+								}
+								var option2134 witTypes.Option[uint64]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) {
+								case 0:
+
+									option2134 = witTypes.None[uint64]()
+								case 1:
+
+									option2134 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))))
+								default:
+									panic("unreachable")
+								}
+								result2138 := make([]golem_api_context.Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))), index*(5*4))
+									value2135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+									var variant2137 golem_api_context.AttributeValue
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+									case 0:
+										value2136 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+										variant2137 = golem_api_context.MakeAttributeValueString(value2136)
+
+									default:
+										panic("unreachable")
+									}
+
+									result2138 = append(result2138, golem_api_context.Attribute{value2135, variant2137})
+								}
+
+								variant2140 = MakeSpanDataLocalSpan(LocalSpanData{value2131, wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))}, option2133, option2134, result2138, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)})
+
+							case 1:
+								value2139 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant2140 = MakeSpanDataExternalSpan(ExternalSpanData{value2139})
+
+							default:
+								panic("unreachable")
+							}
+
+							result2141 = append(result2141, variant2140)
+						}
+
+						result2142 = append(result2142, result2141)
+					}
+
+					variant2146 = MakeAgentInvocationAgentMethodInvocation(AgentMethodInvocationParameters{value1922, value1923, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result2099, result2103, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4)))}, golem_core_types.SchemaValueTree{result2127, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 11*4)))}}, value2128, result2130, result2142})
+
+				case 2:
+
+					variant2146 = MakeAgentInvocationSaveSnapshot()
+
+				case 3:
+					value2143 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+					value2144 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))))
+
+					variant2146 = MakeAgentInvocationLoadSnapshot(LoadSnapshotParameters{SnapshotData{value2143, value2144}})
+
+				case 4:
+					value2145 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+
+					variant2146 = MakeAgentInvocationProcessOplogEntries(ProcessOplogEntriesParameters{value2145})
+
+				case 5:
+
+					variant2146 = MakeAgentInvocationManualUpdate(ManualUpdateParameters{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))})
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryPendingAgentInvocation(PendingAgentInvocationParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, variant2146})
+
+			case 15:
+				var variant2149 UpdateDescription
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+				case 0:
+
+					variant2149 = MakeUpdateDescriptionAutoUpdate()
+
+				case 1:
+					value2147 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))))
+					value2148 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))
+
+					variant2149 = MakeUpdateDescriptionSnapshotBased(golem_api_host.Snapshot{value2147, value2148})
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryPendingUpdate(PendingUpdateParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), variant2149})
+
+			case 16:
+				result2155 := make([]PluginInstallationDescription, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48)))), index*(24+6*4))
+					value2150 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+					value2151 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))))
+					result2154 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 6*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 6*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 5*4))))), index*(4*4))
+						value2152 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+						value2153 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+						result2154 = append(result2154, witTypes.Tuple2[string, string]{value2152, value2153})
+					}
+
+					result2155 = append(result2155, PluginInstallationDescription{EnvironmentPluginGrantId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2150, value2151, result2154})
+				}
+
+				variant2471 = MakePublicOplogEntrySuccessfulUpdate(SuccessfulUpdateParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40))), result2155})
+
+			case 17:
+				var option2157 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+				case 0:
+
+					option2157 = witTypes.None[string]()
+				case 1:
+					value2156 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))))
+
+					option2157 = witTypes.Some[string](value2156)
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryFailedUpdate(FailedUpdateParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), option2157})
+
+			case 18:
+
+				variant2471 = MakePublicOplogEntryGrowMemory(GrowMemoryParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))})
+
+			case 19:
+
+				variant2471 = MakePublicOplogEntryFilesystemStorageUsageUpdate(FilesystemStorageUsageUpdateParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, *(*int64)(unsafe.Add(unsafe.Pointer(base), 32))})
+
+			case 20:
+				value2158 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+				value2159 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))))
+
+				variant2471 = MakePublicOplogEntryCreateResource(CreateResourceParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), value2158, value2159})
+
+			case 21:
+				value2160 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))
+				value2161 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))))
+
+				variant2471 = MakePublicOplogEntryDropResource(DropResourceParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), value2160, value2161})
+
+			case 22:
+				value2162 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4))))
+				value2163 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))
+
+				variant2471 = MakePublicOplogEntryLog(LogParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32)))), value2162, value2163})
+
+			case 23:
+
+				variant2471 = MakePublicOplogEntryRestart(Timestamp{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}})
+
+			case 24:
+				value2164 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4))))
+				value2165 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))
+				result2168 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))), index*(4*4))
+					value2166 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value2167 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result2168 = append(result2168, witTypes.Tuple2[string, string]{value2166, value2167})
+				}
+
+				variant2471 = MakePublicOplogEntryActivatePlugin(ActivatePluginParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, PluginInstallationDescription{EnvironmentPluginGrantId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 48)), value2164, value2165, result2168}})
+
+			case 25:
+				value2169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4))))
+				value2170 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))
+				result2173 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))), index*(4*4))
+					value2171 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value2172 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result2173 = append(result2173, witTypes.Tuple2[string, string]{value2171, value2172})
+				}
+
+				variant2471 = MakePublicOplogEntryDeactivatePlugin(DeactivatePluginParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, PluginInstallationDescription{EnvironmentPluginGrantId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 48)), value2169, value2170, result2173}})
+
+			case 26:
+
+				variant2471 = MakePublicOplogEntryRevert(RevertParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, OplogRegion{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}})
+
+			case 27:
+				value2174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+
+				variant2471 = MakePublicOplogEntryCancelPendingInvocation(CancelPendingInvocationParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, value2174})
+
+			case 28:
+				value2175 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+				var option2177 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))) {
+				case 0:
+
+					option2177 = witTypes.None[string]()
+				case 1:
+					value2176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))
+
+					option2177 = witTypes.Some[string](value2176)
+				default:
+					panic("unreachable")
+				}
+				var option2179 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))) {
+				case 0:
+
+					option2179 = witTypes.None[string]()
+				case 1:
+					value2178 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4))))
+
+					option2179 = witTypes.Some[string](value2178)
+				default:
+					panic("unreachable")
+				}
+				result2183 := make([]golem_api_context.Attribute, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4))))), index*(5*4))
+					value2180 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var variant2182 golem_api_context.AttributeValue
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+						value2181 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+						variant2182 = golem_api_context.MakeAttributeValueString(value2181)
+
+					default:
+						panic("unreachable")
+					}
+
+					result2183 = append(result2183, golem_api_context.Attribute{value2180, variant2182})
+				}
+
+				variant2471 = MakePublicOplogEntryStartSpan(StartSpanParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, value2175, option2177, option2179, result2183})
+
+			case 29:
+				value2184 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+
+				variant2471 = MakePublicOplogEntryFinishSpan(FinishSpanParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, value2184})
+
+			case 30:
+				value2185 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+				value2186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+				var variant2188 golem_api_context.AttributeValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) {
+				case 0:
+					value2187 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))))
+
+					variant2188 = golem_api_context.MakeAttributeValueString(value2187)
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntrySetSpanAttribute(SetSpanAttributeParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, value2185, value2186, variant2188})
+
+			case 31:
+				var variant2189 golem_api_host.PersistenceLevel
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+				case 0:
+
+					variant2189 = golem_api_host.MakePersistenceLevelPersistNothing()
+
+				case 1:
+
+					variant2189 = golem_api_host.MakePersistenceLevelPersistRemoteSideEffects()
+
+				case 2:
+
+					variant2189 = golem_api_host.MakePersistenceLevelSmart()
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryChangePersistenceLevel(ChangePersistenceLevelParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, variant2189})
+
+			case 32:
+				value2190 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+
+				variant2471 = MakePublicOplogEntryBeginRemoteTransaction(BeginRemoteTransactionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, value2190})
+
+			case 33:
+
+				variant2471 = MakePublicOplogEntryPreCommitRemoteTransaction(RemoteTransactionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))})
+
+			case 34:
+
+				variant2471 = MakePublicOplogEntryPreRollbackRemoteTransaction(RemoteTransactionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))})
+
+			case 35:
+
+				variant2471 = MakePublicOplogEntryCommittedRemoteTransaction(RemoteTransactionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))})
+
+			case 36:
+
+				variant2471 = MakePublicOplogEntryRolledBackRemoteTransaction(RemoteTransactionParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))})
+
+			case 37:
+				value2191 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+				value2192 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))
+
+				variant2471 = MakePublicOplogEntrySnapshot(SnapshotParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, SnapshotData{value2191, value2192}})
+
+			case 38:
+				value2193 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4))))
+				value2194 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4))))
+				result2197 := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 5*4))))), index*(4*4))
+					value2195 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					value2196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+					result2197 = append(result2197, witTypes.Tuple2[string, string]{value2195, value2196})
+				}
+
+				value2198 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (72 + 6*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (72 + 7*4))))
+
+				variant2471 = MakePublicOplogEntryOplogProcessorCheckpoint(OplogProcessorCheckpointParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, PluginInstallationDescription{EnvironmentPluginGrantId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 48)), value2193, value2194, result2197}, golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (56 + 6*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 6*4))))}}, value2198}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (72 + 8*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (80 + 8*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (88 + 8*4))))})
+
+			case 39:
+				value2199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+				result2230 := make([]golem_api_retry.PredicateNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4))))), index*(16+4*4))
+					var variant2229 golem_api_retry.PredicateNode
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+						value2200 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2202 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2202 = golem_api_retry.MakePredicateValueText(value2201)
+
+						case 1:
+
+							variant2202 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2202 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2229 = golem_api_retry.MakePredicateNodePropEq(golem_api_retry.PropertyComparison{value2200, variant2202})
+
+					case 1:
+						value2203 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2205 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2204 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2205 = golem_api_retry.MakePredicateValueText(value2204)
+
+						case 1:
+
+							variant2205 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2205 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2229 = golem_api_retry.MakePredicateNodePropNeq(golem_api_retry.PropertyComparison{value2203, variant2205})
+
+					case 2:
+						value2206 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2208 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2207 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2208 = golem_api_retry.MakePredicateValueText(value2207)
+
+						case 1:
+
+							variant2208 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2208 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2229 = golem_api_retry.MakePredicateNodePropGt(golem_api_retry.PropertyComparison{value2206, variant2208})
+
+					case 3:
+						value2209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2211 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2210 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2211 = golem_api_retry.MakePredicateValueText(value2210)
+
+						case 1:
+
+							variant2211 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2211 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2229 = golem_api_retry.MakePredicateNodePropGte(golem_api_retry.PropertyComparison{value2209, variant2211})
+
+					case 4:
+						value2212 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2214 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2213 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2214 = golem_api_retry.MakePredicateValueText(value2213)
+
+						case 1:
+
+							variant2214 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2214 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2229 = golem_api_retry.MakePredicateNodePropLt(golem_api_retry.PropertyComparison{value2212, variant2214})
+
+					case 5:
+						value2215 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant2217 golem_api_retry.PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value2216 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant2217 = golem_api_retry.MakePredicateValueText(value2216)
+
+						case 1:
+
+							variant2217 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant2217 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2229 = golem_api_retry.MakePredicateNodePropLte(golem_api_retry.PropertyComparison{value2215, variant2217})
+
+					case 6:
+						value2218 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant2229 = golem_api_retry.MakePredicateNodePropExists(value2218)
+
+					case 7:
+						value2219 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						result2222 := make([]golem_api_retry.PredicateValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(8+2*4))
+							var variant2221 golem_api_retry.PredicateValue
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value2220 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant2221 = golem_api_retry.MakePredicateValueText(value2220)
+
+							case 1:
+
+								variant2221 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+							case 2:
+
+								variant2221 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+							default:
+								panic("unreachable")
+							}
+
+							result2222 = append(result2222, variant2221)
+						}
+
+						variant2229 = golem_api_retry.MakePredicateNodePropIn(golem_api_retry.PropertySetCheck{value2219, result2222})
+
+					case 8:
+						value2223 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value2224 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant2229 = golem_api_retry.MakePredicateNodePropMatches(golem_api_retry.PropertyPattern{value2223, value2224})
+
+					case 9:
+						value2225 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value2226 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant2229 = golem_api_retry.MakePredicateNodePropStartsWith(golem_api_retry.PropertyPattern{value2225, value2226})
+
+					case 10:
+						value2227 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value2228 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant2229 = golem_api_retry.MakePredicateNodePropContains(golem_api_retry.PropertyPattern{value2227, value2228})
+
+					case 11:
+
+						variant2229 = golem_api_retry.MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 12:
+
+						variant2229 = golem_api_retry.MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 13:
+
+						variant2229 = golem_api_retry.MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 14:
+
+						variant2229 = golem_api_retry.MakePredicateNodePredTrue()
+
+					case 15:
+
+						variant2229 = golem_api_retry.MakePredicateNodePredFalse()
+
+					default:
+						panic("unreachable")
+					}
+
+					result2230 = append(result2230, variant2229)
+				}
+
+				result2263 := make([]golem_api_retry.PolicyNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4))))), index*32)
+					var variant2262 golem_api_retry.PolicyNode
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant2262 = golem_api_retry.MakePolicyNodePeriodic(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 1:
+
+						variant2262 = golem_api_retry.MakePolicyNodeExponential(golem_api_retry.ExponentialConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*float64)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+					case 2:
+
+						variant2262 = golem_api_retry.MakePolicyNodeFibonacci(golem_api_retry.FibonacciConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+					case 3:
+
+						variant2262 = golem_api_retry.MakePolicyNodeImmediate()
+
+					case 4:
+
+						variant2262 = golem_api_retry.MakePolicyNodeNever()
+
+					case 5:
+
+						variant2262 = golem_api_retry.MakePolicyNodeCountBox(golem_api_retry.CountBoxConfig{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 6:
+
+						variant2262 = golem_api_retry.MakePolicyNodeTimeBox(golem_api_retry.TimeBoxConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+					case 7:
+
+						variant2262 = golem_api_retry.MakePolicyNodeClampDelay(golem_api_retry.ClampConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 24))})
+
+					case 8:
+
+						variant2262 = golem_api_retry.MakePolicyNodeAddDelay(golem_api_retry.AddDelayConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+					case 9:
+
+						variant2262 = golem_api_retry.MakePolicyNodeJitter(golem_api_retry.JitterConfig{*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+					case 10:
+						result2261 := make([]golem_api_retry.PredicateNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(16+4*4))
+							var variant2260 golem_api_retry.PredicateNode
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value2231 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2233 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2232 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2233 = golem_api_retry.MakePredicateValueText(value2232)
+
+								case 1:
+
+									variant2233 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2233 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2260 = golem_api_retry.MakePredicateNodePropEq(golem_api_retry.PropertyComparison{value2231, variant2233})
+
+							case 1:
+								value2234 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2236 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2235 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2236 = golem_api_retry.MakePredicateValueText(value2235)
+
+								case 1:
+
+									variant2236 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2236 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2260 = golem_api_retry.MakePredicateNodePropNeq(golem_api_retry.PropertyComparison{value2234, variant2236})
+
+							case 2:
+								value2237 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2239 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2238 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2239 = golem_api_retry.MakePredicateValueText(value2238)
+
+								case 1:
+
+									variant2239 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2239 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2260 = golem_api_retry.MakePredicateNodePropGt(golem_api_retry.PropertyComparison{value2237, variant2239})
+
+							case 3:
+								value2240 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2242 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2241 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2242 = golem_api_retry.MakePredicateValueText(value2241)
+
+								case 1:
+
+									variant2242 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2242 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2260 = golem_api_retry.MakePredicateNodePropGte(golem_api_retry.PropertyComparison{value2240, variant2242})
+
+							case 4:
+								value2243 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2245 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2244 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2245 = golem_api_retry.MakePredicateValueText(value2244)
+
+								case 1:
+
+									variant2245 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2245 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2260 = golem_api_retry.MakePredicateNodePropLt(golem_api_retry.PropertyComparison{value2243, variant2245})
+
+							case 5:
+								value2246 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								var variant2248 golem_api_retry.PredicateValue
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+								case 0:
+									value2247 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+									variant2248 = golem_api_retry.MakePredicateValueText(value2247)
+
+								case 1:
+
+									variant2248 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+								case 2:
+
+									variant2248 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+								default:
+									panic("unreachable")
+								}
+
+								variant2260 = golem_api_retry.MakePredicateNodePropLte(golem_api_retry.PropertyComparison{value2246, variant2248})
+
+							case 6:
+								value2249 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant2260 = golem_api_retry.MakePredicateNodePropExists(value2249)
+
+							case 7:
+								value2250 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								result2253 := make([]golem_api_retry.PredicateValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+								for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+									base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(8+2*4))
+									var variant2252 golem_api_retry.PredicateValue
+									switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+									case 0:
+										value2251 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+										variant2252 = golem_api_retry.MakePredicateValueText(value2251)
+
+									case 1:
+
+										variant2252 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+									case 2:
+
+										variant2252 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+									default:
+										panic("unreachable")
+									}
+
+									result2253 = append(result2253, variant2252)
+								}
+
+								variant2260 = golem_api_retry.MakePredicateNodePropIn(golem_api_retry.PropertySetCheck{value2250, result2253})
+
+							case 8:
+								value2254 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								value2255 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								variant2260 = golem_api_retry.MakePredicateNodePropMatches(golem_api_retry.PropertyPattern{value2254, value2255})
+
+							case 9:
+								value2256 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								value2257 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								variant2260 = golem_api_retry.MakePredicateNodePropStartsWith(golem_api_retry.PropertyPattern{value2256, value2257})
+
+							case 10:
+								value2258 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+								value2259 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+								variant2260 = golem_api_retry.MakePredicateNodePropContains(golem_api_retry.PropertyPattern{value2258, value2259})
+
+							case 11:
+
+								variant2260 = golem_api_retry.MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+							case 12:
+
+								variant2260 = golem_api_retry.MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+							case 13:
+
+								variant2260 = golem_api_retry.MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+							case 14:
+
+								variant2260 = golem_api_retry.MakePredicateNodePredTrue()
+
+							case 15:
+
+								variant2260 = golem_api_retry.MakePredicateNodePredFalse()
+
+							default:
+								panic("unreachable")
+							}
+
+							result2261 = append(result2261, variant2260)
+						}
+
+						variant2262 = golem_api_retry.MakePolicyNodeFilteredOn(golem_api_retry.FilteredConfig{golem_api_retry.RetryPredicate{result2261}, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+					case 11:
+
+						variant2262 = golem_api_retry.MakePolicyNodeAndThen(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 12:
+
+						variant2262 = golem_api_retry.MakePolicyNodePolicyUnion(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 13:
+
+						variant2262 = golem_api_retry.MakePolicyNodePolicyIntersect(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					default:
+						panic("unreachable")
+					}
+
+					result2263 = append(result2263, variant2262)
+				}
+
+				variant2471 = MakePublicOplogEntrySetRetryPolicy(SetRetryPolicyParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, golem_api_retry.NamedRetryPolicy{value2199, uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))), golem_api_retry.RetryPredicate{result2230}, golem_api_retry.RetryPolicy{result2263}}})
+
+			case 40:
+				value2264 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4))))
+
+				variant2471 = MakePublicOplogEntryRemoveRetryPolicy(RemoveRetryPolicyParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, value2264})
+
+			case 41:
+				var variant2265 QueuedCardEvent
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+				case 0:
+
+					variant2265 = MakeQueuedCardEventInstall(QueuedCardEventInstall{golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 48)))}}})
+
+				case 1:
+
+					variant2265 = MakeQueuedCardEventRevoke(QueuedCardEventRevoke{golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 48)))}}})
+
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryCardEventQueued(CardEventQueuedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, variant2265})
+
+			case 42:
+				var option2266 witTypes.Option[uint64]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+				case 0:
+
+					option2266 = witTypes.None[uint64]()
+				case 1:
+
+					option2266 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40))))
+				default:
+					panic("unreachable")
+				}
+
+				variant2471 = MakePublicOplogEntryCardInstalled(CardInstalledParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, option2266, golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 48))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))}}})
+
+			case 43:
+
+				variant2471 = MakePublicOplogEntryCardInstallFailed(CardInstallFailedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 48)))}}, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 56))))})
+
+			case 44:
+
+				variant2471 = MakePublicOplogEntryCardRevoked(CardRevokedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 48)))}}})
+
+			case 45:
+
+				variant2471 = MakePublicOplogEntryCardExpired(CardExpiredParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, golem_core_types.CardId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}}})
+
+			case 46:
+				result2442 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4))))), index*(56+22*4))
+					var variant2430 golem_core_types.SchemaTypeBody
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 1:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+					case 2:
+						var option2273 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2273 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2268 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2268 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2267 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2267 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2267 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2267 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2268 = witTypes.Some[golem_core_types.NumericBound](variant2267)
+							default:
+								panic("unreachable")
+							}
+							var option2270 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2270 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2269 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2269 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2269 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2269 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2270 = witTypes.Some[golem_core_types.NumericBound](variant2269)
+							default:
+								panic("unreachable")
+							}
+							var option2272 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2272 = witTypes.None[string]()
+							case 1:
+								value2271 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2272 = witTypes.Some[string](value2271)
+							default:
+								panic("unreachable")
+							}
+
+							option2273 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2268, option2270, option2272})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyS8Type(option2273)
+
+					case 3:
+						var option2280 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2280 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2275 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2275 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2274 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2274 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2274 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2274 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2275 = witTypes.Some[golem_core_types.NumericBound](variant2274)
+							default:
+								panic("unreachable")
+							}
+							var option2277 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2277 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2276 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2276 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2276 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2276 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2277 = witTypes.Some[golem_core_types.NumericBound](variant2276)
+							default:
+								panic("unreachable")
+							}
+							var option2279 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2279 = witTypes.None[string]()
+							case 1:
+								value2278 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2279 = witTypes.Some[string](value2278)
+							default:
+								panic("unreachable")
+							}
+
+							option2280 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2275, option2277, option2279})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyS16Type(option2280)
+
+					case 4:
+						var option2287 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2287 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2282 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2282 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2281 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2281 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2281 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2281 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2282 = witTypes.Some[golem_core_types.NumericBound](variant2281)
+							default:
+								panic("unreachable")
+							}
+							var option2284 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2284 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2283 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2283 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2283 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2283 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2284 = witTypes.Some[golem_core_types.NumericBound](variant2283)
+							default:
+								panic("unreachable")
+							}
+							var option2286 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2286 = witTypes.None[string]()
+							case 1:
+								value2285 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2286 = witTypes.Some[string](value2285)
+							default:
+								panic("unreachable")
+							}
+
+							option2287 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2282, option2284, option2286})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyS32Type(option2287)
+
+					case 5:
+						var option2294 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2294 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2289 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2289 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2288 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2288 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2288 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2288 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2289 = witTypes.Some[golem_core_types.NumericBound](variant2288)
+							default:
+								panic("unreachable")
+							}
+							var option2291 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2291 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2290 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2290 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2290 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2290 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2291 = witTypes.Some[golem_core_types.NumericBound](variant2290)
+							default:
+								panic("unreachable")
+							}
+							var option2293 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2293 = witTypes.None[string]()
+							case 1:
+								value2292 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2293 = witTypes.Some[string](value2292)
+							default:
+								panic("unreachable")
+							}
+
+							option2294 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2289, option2291, option2293})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyS64Type(option2294)
+
+					case 6:
+						var option2301 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2301 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2296 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2296 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2295 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2295 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2295 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2295 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2296 = witTypes.Some[golem_core_types.NumericBound](variant2295)
+							default:
+								panic("unreachable")
+							}
+							var option2298 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2298 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2297 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2297 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2297 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2297 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2298 = witTypes.Some[golem_core_types.NumericBound](variant2297)
+							default:
+								panic("unreachable")
+							}
+							var option2300 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2300 = witTypes.None[string]()
+							case 1:
+								value2299 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2300 = witTypes.Some[string](value2299)
+							default:
+								panic("unreachable")
+							}
+
+							option2301 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2296, option2298, option2300})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyU8Type(option2301)
+
+					case 7:
+						var option2308 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2308 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2303 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2303 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2302 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2302 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2302 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2302 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2303 = witTypes.Some[golem_core_types.NumericBound](variant2302)
+							default:
+								panic("unreachable")
+							}
+							var option2305 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2305 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2304 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2304 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2304 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2304 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2305 = witTypes.Some[golem_core_types.NumericBound](variant2304)
+							default:
+								panic("unreachable")
+							}
+							var option2307 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2307 = witTypes.None[string]()
+							case 1:
+								value2306 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2307 = witTypes.Some[string](value2306)
+							default:
+								panic("unreachable")
+							}
+
+							option2308 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2303, option2305, option2307})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyU16Type(option2308)
+
+					case 8:
+						var option2315 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2315 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2310 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2310 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2309 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2309 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2309 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2309 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2310 = witTypes.Some[golem_core_types.NumericBound](variant2309)
+							default:
+								panic("unreachable")
+							}
+							var option2312 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2312 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2311 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2311 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2311 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2311 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2312 = witTypes.Some[golem_core_types.NumericBound](variant2311)
+							default:
+								panic("unreachable")
+							}
+							var option2314 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2314 = witTypes.None[string]()
+							case 1:
+								value2313 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2314 = witTypes.Some[string](value2313)
+							default:
+								panic("unreachable")
+							}
+
+							option2315 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2310, option2312, option2314})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyU32Type(option2315)
+
+					case 9:
+						var option2322 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2322 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2317 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2317 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2316 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2316 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2316 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2316 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2317 = witTypes.Some[golem_core_types.NumericBound](variant2316)
+							default:
+								panic("unreachable")
+							}
+							var option2319 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2319 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2318 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2318 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2318 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2318 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2319 = witTypes.Some[golem_core_types.NumericBound](variant2318)
+							default:
+								panic("unreachable")
+							}
+							var option2321 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2321 = witTypes.None[string]()
+							case 1:
+								value2320 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2321 = witTypes.Some[string](value2320)
+							default:
+								panic("unreachable")
+							}
+
+							option2322 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2317, option2319, option2321})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyU64Type(option2322)
+
+					case 10:
+						var option2329 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2329 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2324 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2324 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2323 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2323 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2323 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2323 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2324 = witTypes.Some[golem_core_types.NumericBound](variant2323)
+							default:
+								panic("unreachable")
+							}
+							var option2326 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2326 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2325 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2325 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2325 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2325 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2326 = witTypes.Some[golem_core_types.NumericBound](variant2325)
+							default:
+								panic("unreachable")
+							}
+							var option2328 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2328 = witTypes.None[string]()
+							case 1:
+								value2327 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2328 = witTypes.Some[string](value2327)
+							default:
+								panic("unreachable")
+							}
+
+							option2329 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2324, option2326, option2328})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyF32Type(option2329)
+
+					case 11:
+						var option2336 witTypes.Option[golem_core_types.NumericRestrictions]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2336 = witTypes.None[golem_core_types.NumericRestrictions]()
+						case 1:
+							var option2331 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+							case 0:
+
+								option2331 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2330 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+								case 0:
+
+									variant2330 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+								case 1:
+
+									variant2330 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								case 2:
+
+									variant2330 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2331 = witTypes.Some[golem_core_types.NumericBound](variant2330)
+							default:
+								panic("unreachable")
+							}
+							var option2333 witTypes.Option[golem_core_types.NumericBound]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+							case 0:
+
+								option2333 = witTypes.None[golem_core_types.NumericBound]()
+							case 1:
+								var variant2332 golem_core_types.NumericBound
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+								case 0:
+
+									variant2332 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+								case 1:
+
+									variant2332 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								case 2:
+
+									variant2332 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+								default:
+									panic("unreachable")
+								}
+
+								option2333 = witTypes.Some[golem_core_types.NumericBound](variant2332)
+							default:
+								panic("unreachable")
+							}
+							var option2335 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+							case 0:
+
+								option2335 = witTypes.None[string]()
+							case 1:
+								value2334 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+								option2335 = witTypes.Some[string](value2334)
+							default:
+								panic("unreachable")
+							}
+
+							option2336 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2331, option2333, option2335})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyF64Type(option2336)
+
+					case 12:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+					case 13:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+					case 14:
+						result2349 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+							value2337 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var option2339 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+							case 0:
+
+								option2339 = witTypes.None[string]()
+							case 1:
+								value2338 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								option2339 = witTypes.Some[string](value2338)
+							default:
+								panic("unreachable")
+							}
+							result2341 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+								value2340 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2341 = append(result2341, value2340)
+							}
+
+							result2343 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+								value2342 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2343 = append(result2343, value2342)
+							}
+
+							var option2345 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+							case 0:
+
+								option2345 = witTypes.None[string]()
+							case 1:
+								value2344 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+								option2345 = witTypes.Some[string](value2344)
+							default:
+								panic("unreachable")
+							}
+							var option2348 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+							case 0:
+
+								option2348 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant2347 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+								case 0:
+
+									variant2347 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant2347 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant2347 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value2346 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+									variant2347 = golem_core_types.MakeRoleOther(value2346)
+
+								default:
+									panic("unreachable")
+								}
+
+								option2348 = witTypes.Some[golem_core_types.Role](variant2347)
+							default:
+								panic("unreachable")
+							}
+
+							result2349 = append(result2349, golem_core_types.NamedFieldType{value2337, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option2339, result2341, result2343, option2345, option2348}})
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyRecordType(result2349)
+
+					case 15:
+						result2363 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+							value2350 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var option2351 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+							case 0:
+
+								option2351 = witTypes.None[int32]()
+							case 1:
+
+								option2351 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+							default:
+								panic("unreachable")
+							}
+							var option2353 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+							case 0:
+
+								option2353 = witTypes.None[string]()
+							case 1:
+								value2352 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+								option2353 = witTypes.Some[string](value2352)
+							default:
+								panic("unreachable")
+							}
+							result2355 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+								value2354 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2355 = append(result2355, value2354)
+							}
+
+							result2357 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+								value2356 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2357 = append(result2357, value2356)
+							}
+
+							var option2359 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+							case 0:
+
+								option2359 = witTypes.None[string]()
+							case 1:
+								value2358 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+								option2359 = witTypes.Some[string](value2358)
+							default:
+								panic("unreachable")
+							}
+							var option2362 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+							case 0:
+
+								option2362 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant2361 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+								case 0:
+
+									variant2361 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant2361 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant2361 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value2360 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+									variant2361 = golem_core_types.MakeRoleOther(value2360)
+
+								default:
+									panic("unreachable")
+								}
+
+								option2362 = witTypes.Some[golem_core_types.Role](variant2361)
+							default:
+								panic("unreachable")
+							}
+
+							result2363 = append(result2363, golem_core_types.VariantCaseType{value2350, option2351, golem_core_types.MetadataEnvelope{option2353, result2355, result2357, option2359, option2362}})
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyVariantType(result2363)
+
+					case 16:
+						result2365 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+							value2364 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2365 = append(result2365, value2364)
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyEnumType(result2365)
+
+					case 17:
+						result2367 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+							value2366 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2367 = append(result2367, value2366)
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyFlagsType(result2367)
+
+					case 18:
+						result2368 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result2368 = append(result2368, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyTupleType(result2368)
+
+					case 19:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 20:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+					case 21:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 22:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 23:
+						var option2369 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2369 = witTypes.None[int32]()
+						case 1:
+
+							option2369 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+						var option2370 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+						case 0:
+
+							option2370 = witTypes.None[int32]()
+						case 1:
+
+							option2370 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option2369, option2370})
+
+					case 24:
+						var option2373 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2373 = witTypes.None[[]string]()
+						case 1:
+							result2372 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value2371 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2372 = append(result2372, value2371)
+							}
+
+							option2373 = witTypes.Some[[]string](result2372)
+						default:
+							panic("unreachable")
+						}
+						var option2374 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option2374 = witTypes.None[uint32]()
+						case 1:
+
+							option2374 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option2375 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+						case 0:
+
+							option2375 = witTypes.None[uint32]()
+						case 1:
+
+							option2375 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option2377 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+						case 0:
+
+							option2377 = witTypes.None[string]()
+						case 1:
+							value2376 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+							option2377 = witTypes.Some[string](value2376)
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option2373, option2374, option2375, option2377})
+
+					case 25:
+						var option2380 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2380 = witTypes.None[[]string]()
+						case 1:
+							result2379 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value2378 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2379 = append(result2379, value2378)
+							}
+
+							option2380 = witTypes.Some[[]string](result2379)
+						default:
+							panic("unreachable")
+						}
+						var option2381 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option2381 = witTypes.None[uint32]()
+						case 1:
+
+							option2381 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+						var option2382 witTypes.Option[uint32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+						case 0:
+
+							option2382 = witTypes.None[uint32]()
+						case 1:
+
+							option2382 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option2380, option2381, option2382})
+
+					case 26:
+						var option2385 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+						case 0:
+
+							option2385 = witTypes.None[[]string]()
+						case 1:
+							result2384 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+								value2383 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2384 = append(result2384, value2383)
+							}
+
+							option2385 = witTypes.Some[[]string](result2384)
+						default:
+							panic("unreachable")
+						}
+						var option2388 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+						case 0:
+
+							option2388 = witTypes.None[[]string]()
+						case 1:
+							result2387 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+								value2386 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2387 = append(result2387, value2386)
+							}
+
+							option2388 = witTypes.Some[[]string](result2387)
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option2385, option2388})
+
+					case 27:
+						var option2391 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2391 = witTypes.None[[]string]()
+						case 1:
+							result2390 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+								value2389 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2390 = append(result2390, value2389)
+							}
+
+							option2391 = witTypes.Some[[]string](result2390)
+						default:
+							panic("unreachable")
+						}
+						var option2394 witTypes.Option[[]string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+						case 0:
+
+							option2394 = witTypes.None[[]string]()
+						case 1:
+							result2393 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+								value2392 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2393 = append(result2393, value2392)
+							}
+
+							option2394 = witTypes.Some[[]string](result2393)
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option2391, option2394})
+
+					case 28:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+					case 29:
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+					case 30:
+						value2395 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						result2397 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+							value2396 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+							result2397 = append(result2397, value2396)
+						}
+
+						var option2399 witTypes.Option[golem_core_types.QuantityValue]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+						case 0:
+
+							option2399 = witTypes.None[golem_core_types.QuantityValue]()
+						case 1:
+							value2398 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+							option2399 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value2398})
+						default:
+							panic("unreachable")
+						}
+						var option2401 witTypes.Option[golem_core_types.QuantityValue]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+						case 0:
+
+							option2401 = witTypes.None[golem_core_types.QuantityValue]()
+						case 1:
+							value2400 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+							option2401 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value2400})
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value2395, result2397, option2399, option2401})
+
+					case 31:
+						result2423 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+							value2402 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+							var variant2411 golem_core_types.DiscriminatorRule
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+							case 0:
+								value2403 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant2411 = golem_core_types.MakeDiscriminatorRulePrefix(value2403)
+
+							case 1:
+								value2404 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant2411 = golem_core_types.MakeDiscriminatorRuleSuffix(value2404)
+
+							case 2:
+								value2405 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant2411 = golem_core_types.MakeDiscriminatorRuleContains(value2405)
+
+							case 3:
+								value2406 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant2411 = golem_core_types.MakeDiscriminatorRuleRegex(value2406)
+
+							case 4:
+								value2407 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+								var option2409 witTypes.Option[string]
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+								case 0:
+
+									option2409 = witTypes.None[string]()
+								case 1:
+									value2408 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+									option2409 = witTypes.Some[string](value2408)
+								default:
+									panic("unreachable")
+								}
+
+								variant2411 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value2407, option2409})
+
+							case 5:
+								value2410 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+								variant2411 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value2410)
+
+							default:
+								panic("unreachable")
+							}
+							var option2413 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+							case 0:
+
+								option2413 = witTypes.None[string]()
+							case 1:
+								value2412 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+								option2413 = witTypes.Some[string](value2412)
+							default:
+								panic("unreachable")
+							}
+							result2415 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+								value2414 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2415 = append(result2415, value2414)
+							}
+
+							result2417 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+							for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+								base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+								value2416 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+								result2417 = append(result2417, value2416)
+							}
+
+							var option2419 witTypes.Option[string]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+							case 0:
+
+								option2419 = witTypes.None[string]()
+							case 1:
+								value2418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+								option2419 = witTypes.Some[string](value2418)
+							default:
+								panic("unreachable")
+							}
+							var option2422 witTypes.Option[golem_core_types.Role]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+							case 0:
+
+								option2422 = witTypes.None[golem_core_types.Role]()
+							case 1:
+								var variant2421 golem_core_types.Role
+								switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+								case 0:
+
+									variant2421 = golem_core_types.MakeRoleMultimodal()
+
+								case 1:
+
+									variant2421 = golem_core_types.MakeRoleUnstructuredText()
+
+								case 2:
+
+									variant2421 = golem_core_types.MakeRoleUnstructuredBinary()
+
+								case 3:
+									value2420 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+									variant2421 = golem_core_types.MakeRoleOther(value2420)
+
+								default:
+									panic("unreachable")
+								}
+
+								option2422 = witTypes.Some[golem_core_types.Role](variant2421)
+							default:
+								panic("unreachable")
+							}
+
+							result2423 = append(result2423, golem_core_types.UnionBranch{value2402, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant2411, golem_core_types.MetadataEnvelope{option2413, result2415, result2417, option2419, option2422}})
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result2423})
+
+					case 32:
+						var option2425 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+						case 0:
+
+							option2425 = witTypes.None[string]()
+						case 1:
+							value2424 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+							option2425 = witTypes.Some[string](value2424)
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option2425})
+
+					case 33:
+						var option2427 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2427 = witTypes.None[string]()
+						case 1:
+							value2426 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+							option2427 = witTypes.Some[string](value2426)
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option2427})
+
+					case 34:
+						var option2428 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2428 = witTypes.None[int32]()
+						case 1:
+
+							option2428 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyFutureType(option2428)
+
+					case 35:
+						var option2429 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2429 = witTypes.None[int32]()
+						case 1:
+
+							option2429 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant2430 = golem_core_types.MakeSchemaTypeBodyStreamType(option2429)
+
+					default:
+						panic("unreachable")
+					}
+					var option2432 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+					case 0:
+
+						option2432 = witTypes.None[string]()
+					case 1:
+						value2431 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+						option2432 = witTypes.Some[string](value2431)
+					default:
+						panic("unreachable")
+					}
+					result2434 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+						value2433 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result2434 = append(result2434, value2433)
+					}
+
+					result2436 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+						value2435 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+						result2436 = append(result2436, value2435)
+					}
+
+					var option2438 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+					case 0:
+
+						option2438 = witTypes.None[string]()
+					case 1:
+						value2437 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+						option2438 = witTypes.Some[string](value2437)
+					default:
+						panic("unreachable")
+					}
+					var option2441 witTypes.Option[golem_core_types.Role]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+					case 0:
+
+						option2441 = witTypes.None[golem_core_types.Role]()
+					case 1:
+						var variant2440 golem_core_types.Role
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+						case 0:
+
+							variant2440 = golem_core_types.MakeRoleMultimodal()
+
+						case 1:
+
+							variant2440 = golem_core_types.MakeRoleUnstructuredText()
+
+						case 2:
+
+							variant2440 = golem_core_types.MakeRoleUnstructuredBinary()
+
+						case 3:
+							value2439 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+							variant2440 = golem_core_types.MakeRoleOther(value2439)
+
+						default:
+							panic("unreachable")
+						}
+
+						option2441 = witTypes.Some[golem_core_types.Role](variant2440)
+					default:
+						panic("unreachable")
+					}
+
+					result2442 = append(result2442, golem_core_types.SchemaTypeNode{variant2430, golem_core_types.MetadataEnvelope{option2432, result2434, result2436, option2438, option2441}})
+				}
+
+				result2446 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4))))), index*(6*4))
+					value2443 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+					var option2445 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+					case 0:
+
+						option2445 = witTypes.None[string]()
+					case 1:
+						value2444 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+						option2445 = witTypes.Some[string](value2444)
+					default:
+						panic("unreachable")
+					}
+
+					result2446 = append(result2446, golem_core_types.SchemaTypeDef{value2443, option2445, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+				}
+
+				result2470 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 7*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 7*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))))), index*(16+4*4))
+					var variant2469 golem_core_types.SchemaValueNode
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+					case 1:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 2:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 3:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 4:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 5:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 6:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 7:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 8:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 9:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 10:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 11:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 12:
+						value2447 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeStringValue(value2447)
+
+					case 13:
+						result2448 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result2448 = append(result2448, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeRecordValue(result2448)
+
+					case 14:
+						var option2449 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+						case 0:
+
+							option2449 = witTypes.None[int32]()
+						case 1:
+
+							option2449 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+						default:
+							panic("unreachable")
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option2449})
+
+					case 15:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+					case 16:
+						result2450 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+							result2450 = append(result2450, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeFlagsValue(result2450)
+
+					case 17:
+						result2451 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result2451 = append(result2451, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeTupleValue(result2451)
+
+					case 18:
+						result2452 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result2452 = append(result2452, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeListValue(result2452)
+
+					case 19:
+						result2453 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+							result2453 = append(result2453, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeFixedListValue(result2453)
+
+					case 20:
+						result2454 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+							result2454 = append(result2454, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeMapValue(result2454)
+
+					case 21:
+						var option2455 witTypes.Option[int32]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+
+							option2455 = witTypes.None[int32]()
+						case 1:
+
+							option2455 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+						default:
+							panic("unreachable")
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeOptionValue(option2455)
+
+					case 22:
+						var variant2458 golem_core_types.ResultValuePayload
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+						case 0:
+							var option2456 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option2456 = witTypes.None[int32]()
+							case 1:
+
+								option2456 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2458 = golem_core_types.MakeResultValuePayloadOkValue(option2456)
+
+						case 1:
+							var option2457 witTypes.Option[int32]
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+							case 0:
+
+								option2457 = witTypes.None[int32]()
+							case 1:
+
+								option2457 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+							default:
+								panic("unreachable")
+							}
+
+							variant2458 = golem_core_types.MakeResultValuePayloadErrValue(option2457)
+
+						default:
+							panic("unreachable")
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeResultValue(variant2458)
+
+					case 23:
+						value2459 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var option2461 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option2461 = witTypes.None[string]()
+						case 1:
+							value2460 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option2461 = witTypes.Some[string](value2460)
+						default:
+							panic("unreachable")
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value2459, option2461})
+
+					case 24:
+						value2462 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var option2464 witTypes.Option[string]
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+
+							option2464 = witTypes.None[string]()
+						case 1:
+							value2463 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+							option2464 = witTypes.Some[string](value2463)
+						default:
+							panic("unreachable")
+						}
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value2462, option2464})
+
+					case 25:
+						value2465 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant2469 = golem_core_types.MakeSchemaValueNodePathValue(value2465)
+
+					case 26:
+						value2466 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeUrlValue(value2466)
+
+					case 27:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+					case 28:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+					case 29:
+						value2467 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2467})
+
+					case 30:
+						value2468 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value2468, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+					case 31:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+					case 32:
+
+						variant2469 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+					default:
+						panic("unreachable")
+					}
+
+					result2470 = append(result2470, variant2469)
+				}
+
+				variant2471 = MakePublicOplogEntryHostStreamFrame(HostStreamFrameParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)))), golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result2442, result2446, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4)))}, golem_core_types.SchemaValueTree{result2470, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4)))}}})
+
+			case 47:
+
+				variant2471 = MakePublicOplogEntryCompletionDiscarded(CompletionDiscardedParameters{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))})
+
+			default:
+				panic("unreachable")
+			}
+
+			result2472 = append(result2472, witTypes.Tuple2[uint64, PublicOplogEntry]{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), variant2471})
+		}
+
+		option2473 = witTypes.Some[[]witTypes.Tuple2[uint64, PublicOplogEntry]](result2472)
+	default:
+		panic("unreachable")
+	}
+	result2474 := option2473
+	return result2474
+
+}
diff --git a/sdks/go/golem/internal/wit/golem_api_retry/empty.s b/sdks/go/golem/internal/wit/golem_api_retry/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_api_retry/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_api_retry/wit_bindings.go b/sdks/go/golem/internal/wit/golem_api_retry/wit_bindings.go
new file mode 100644
index 0000000000..68c9428842
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_api_retry/wit_bindings.go
@@ -0,0 +1,2729 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_api_retry
+
+import (
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type Duration = uint64
+
+const (
+	PredicateValueText    uint8 = 0
+	PredicateValueInteger uint8 = 1
+	PredicateValueBoolean uint8 = 2
+)
+
+// ── Predicate value ──────────────────────────────────────────────
+// Dynamic value for property comparisons in retry predicates
+type PredicateValue struct {
+	tag   uint8
+	value any
+}
+
+func (self PredicateValue) Tag() uint8 {
+	return self.tag
+}
+
+func (self PredicateValue) Text() string {
+	if self.tag != PredicateValueText {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self PredicateValue) Integer() int64 {
+	if self.tag != PredicateValueInteger {
+		panic("tag mismatch")
+	}
+	return self.value.(int64)
+}
+func (self PredicateValue) Boolean() bool {
+	if self.tag != PredicateValueBoolean {
+		panic("tag mismatch")
+	}
+	return self.value.(bool)
+}
+
+func MakePredicateValueText(value string) PredicateValue {
+	return PredicateValue{PredicateValueText, value}
+}
+func MakePredicateValueInteger(value int64) PredicateValue {
+	return PredicateValue{PredicateValueInteger, value}
+}
+func MakePredicateValueBoolean(value bool) PredicateValue {
+	return PredicateValue{PredicateValueBoolean, value}
+}
+
+// ── Predicate tree (flattened) ───────────────────────────────────
+// Index into a retry-predicate's node list
+type PredicateNodeIndex = int32
+
+type PropertyComparison struct {
+	PropertyName string
+	Value        PredicateValue
+}
+
+type PropertySetCheck struct {
+	PropertyName string
+	Values       []PredicateValue
+}
+
+type PropertyPattern struct {
+	PropertyName string
+	Pattern      string
+}
+
+const (
+	PredicateNodePropEq         uint8 = 0
+	PredicateNodePropNeq        uint8 = 1
+	PredicateNodePropGt         uint8 = 2
+	PredicateNodePropGte        uint8 = 3
+	PredicateNodePropLt         uint8 = 4
+	PredicateNodePropLte        uint8 = 5
+	PredicateNodePropExists     uint8 = 6
+	PredicateNodePropIn         uint8 = 7
+	PredicateNodePropMatches    uint8 = 8
+	PredicateNodePropStartsWith uint8 = 9
+	PredicateNodePropContains   uint8 = 10
+	PredicateNodePredAnd        uint8 = 11
+	PredicateNodePredOr         uint8 = 12
+	PredicateNodePredNot        uint8 = 13
+	PredicateNodePredTrue       uint8 = 14
+	PredicateNodePredFalse      uint8 = 15
+)
+
+type PredicateNode struct {
+	tag   uint8
+	value any
+}
+
+func (self PredicateNode) Tag() uint8 {
+	return self.tag
+}
+
+func (self PredicateNode) PropEq() PropertyComparison {
+	if self.tag != PredicateNodePropEq {
+		panic("tag mismatch")
+	}
+	return self.value.(PropertyComparison)
+}
+func (self PredicateNode) PropNeq() PropertyComparison {
+	if self.tag != PredicateNodePropNeq {
+		panic("tag mismatch")
+	}
+	return self.value.(PropertyComparison)
+}
+func (self PredicateNode) PropGt() PropertyComparison {
+	if self.tag != PredicateNodePropGt {
+		panic("tag mismatch")
+	}
+	return self.value.(PropertyComparison)
+}
+func (self PredicateNode) PropGte() PropertyComparison {
+	if self.tag != PredicateNodePropGte {
+		panic("tag mismatch")
+	}
+	return self.value.(PropertyComparison)
+}
+func (self PredicateNode) PropLt() PropertyComparison {
+	if self.tag != PredicateNodePropLt {
+		panic("tag mismatch")
+	}
+	return self.value.(PropertyComparison)
+}
+func (self PredicateNode) PropLte() PropertyComparison {
+	if self.tag != PredicateNodePropLte {
+		panic("tag mismatch")
+	}
+	return self.value.(PropertyComparison)
+}
+func (self PredicateNode) PropExists() string {
+	if self.tag != PredicateNodePropExists {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self PredicateNode) PropIn() PropertySetCheck {
+	if self.tag != PredicateNodePropIn {
+		panic("tag mismatch")
+	}
+	return self.value.(PropertySetCheck)
+}
+func (self PredicateNode) PropMatches() PropertyPattern {
+	if self.tag != PredicateNodePropMatches {
+		panic("tag mismatch")
+	}
+	return self.value.(PropertyPattern)
+}
+func (self PredicateNode) PropStartsWith() PropertyPattern {
+	if self.tag != PredicateNodePropStartsWith {
+		panic("tag mismatch")
+	}
+	return self.value.(PropertyPattern)
+}
+func (self PredicateNode) PropContains() PropertyPattern {
+	if self.tag != PredicateNodePropContains {
+		panic("tag mismatch")
+	}
+	return self.value.(PropertyPattern)
+}
+func (self PredicateNode) PredAnd() witTypes.Tuple2[int32, int32] {
+	if self.tag != PredicateNodePredAnd {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Tuple2[int32, int32])
+}
+func (self PredicateNode) PredOr() witTypes.Tuple2[int32, int32] {
+	if self.tag != PredicateNodePredOr {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Tuple2[int32, int32])
+}
+func (self PredicateNode) PredNot() int32 {
+	if self.tag != PredicateNodePredNot {
+		panic("tag mismatch")
+	}
+	return self.value.(int32)
+}
+
+func MakePredicateNodePropEq(value PropertyComparison) PredicateNode {
+	return PredicateNode{PredicateNodePropEq, value}
+}
+func MakePredicateNodePropNeq(value PropertyComparison) PredicateNode {
+	return PredicateNode{PredicateNodePropNeq, value}
+}
+func MakePredicateNodePropGt(value PropertyComparison) PredicateNode {
+	return PredicateNode{PredicateNodePropGt, value}
+}
+func MakePredicateNodePropGte(value PropertyComparison) PredicateNode {
+	return PredicateNode{PredicateNodePropGte, value}
+}
+func MakePredicateNodePropLt(value PropertyComparison) PredicateNode {
+	return PredicateNode{PredicateNodePropLt, value}
+}
+func MakePredicateNodePropLte(value PropertyComparison) PredicateNode {
+	return PredicateNode{PredicateNodePropLte, value}
+}
+func MakePredicateNodePropExists(value string) PredicateNode {
+	return PredicateNode{PredicateNodePropExists, value}
+}
+func MakePredicateNodePropIn(value PropertySetCheck) PredicateNode {
+	return PredicateNode{PredicateNodePropIn, value}
+}
+func MakePredicateNodePropMatches(value PropertyPattern) PredicateNode {
+	return PredicateNode{PredicateNodePropMatches, value}
+}
+func MakePredicateNodePropStartsWith(value PropertyPattern) PredicateNode {
+	return PredicateNode{PredicateNodePropStartsWith, value}
+}
+func MakePredicateNodePropContains(value PropertyPattern) PredicateNode {
+	return PredicateNode{PredicateNodePropContains, value}
+}
+func MakePredicateNodePredAnd(value witTypes.Tuple2[int32, int32]) PredicateNode {
+	return PredicateNode{PredicateNodePredAnd, value}
+}
+func MakePredicateNodePredOr(value witTypes.Tuple2[int32, int32]) PredicateNode {
+	return PredicateNode{PredicateNodePredOr, value}
+}
+func MakePredicateNodePredNot(value int32) PredicateNode {
+	return PredicateNode{PredicateNodePredNot, value}
+}
+func MakePredicateNodePredTrue() PredicateNode {
+	return PredicateNode{PredicateNodePredTrue, nil}
+}
+func MakePredicateNodePredFalse() PredicateNode {
+	return PredicateNode{PredicateNodePredFalse, nil}
+}
+
+// A composable predicate tree for matching retry contexts.
+// Root is nodes[0]. Children referenced by predicate-node-index.
+type RetryPredicate struct {
+	Nodes []PredicateNode
+}
+
+// ── Policy tree (flattened) ──────────────────────────────────────
+// Index into a retry-policy's node list
+type PolicyNodeIndex = int32
+
+type ExponentialConfig struct {
+	BaseDelay uint64
+	Factor    float64
+}
+
+type FibonacciConfig struct {
+	First  uint64
+	Second uint64
+}
+
+type CountBoxConfig struct {
+	MaxRetries uint32
+	Inner      int32
+}
+
+type TimeBoxConfig struct {
+	Limit uint64
+	Inner int32
+}
+
+type ClampConfig struct {
+	MinDelay uint64
+	MaxDelay uint64
+	Inner    int32
+}
+
+type AddDelayConfig struct {
+	Delay uint64
+	Inner int32
+}
+
+type JitterConfig struct {
+	Factor float64
+	Inner  int32
+}
+
+// filtered-config embeds a full retry-predicate inline (self-contained)
+type FilteredConfig struct {
+	Predicate RetryPredicate
+	Inner     int32
+}
+
+const (
+	PolicyNodePeriodic        uint8 = 0
+	PolicyNodeExponential     uint8 = 1
+	PolicyNodeFibonacci       uint8 = 2
+	PolicyNodeImmediate       uint8 = 3
+	PolicyNodeNever           uint8 = 4
+	PolicyNodeCountBox        uint8 = 5
+	PolicyNodeTimeBox         uint8 = 6
+	PolicyNodeClampDelay      uint8 = 7
+	PolicyNodeAddDelay        uint8 = 8
+	PolicyNodeJitter          uint8 = 9
+	PolicyNodeFilteredOn      uint8 = 10
+	PolicyNodeAndThen         uint8 = 11
+	PolicyNodePolicyUnion     uint8 = 12
+	PolicyNodePolicyIntersect uint8 = 13
+)
+
+type PolicyNode struct {
+	tag   uint8
+	value any
+}
+
+func (self PolicyNode) Tag() uint8 {
+	return self.tag
+}
+
+func (self PolicyNode) Periodic() uint64 {
+	if self.tag != PolicyNodePeriodic {
+		panic("tag mismatch")
+	}
+	return self.value.(uint64)
+}
+func (self PolicyNode) Exponential() ExponentialConfig {
+	if self.tag != PolicyNodeExponential {
+		panic("tag mismatch")
+	}
+	return self.value.(ExponentialConfig)
+}
+func (self PolicyNode) Fibonacci() FibonacciConfig {
+	if self.tag != PolicyNodeFibonacci {
+		panic("tag mismatch")
+	}
+	return self.value.(FibonacciConfig)
+}
+func (self PolicyNode) CountBox() CountBoxConfig {
+	if self.tag != PolicyNodeCountBox {
+		panic("tag mismatch")
+	}
+	return self.value.(CountBoxConfig)
+}
+func (self PolicyNode) TimeBox() TimeBoxConfig {
+	if self.tag != PolicyNodeTimeBox {
+		panic("tag mismatch")
+	}
+	return self.value.(TimeBoxConfig)
+}
+func (self PolicyNode) ClampDelay() ClampConfig {
+	if self.tag != PolicyNodeClampDelay {
+		panic("tag mismatch")
+	}
+	return self.value.(ClampConfig)
+}
+func (self PolicyNode) AddDelay() AddDelayConfig {
+	if self.tag != PolicyNodeAddDelay {
+		panic("tag mismatch")
+	}
+	return self.value.(AddDelayConfig)
+}
+func (self PolicyNode) Jitter() JitterConfig {
+	if self.tag != PolicyNodeJitter {
+		panic("tag mismatch")
+	}
+	return self.value.(JitterConfig)
+}
+func (self PolicyNode) FilteredOn() FilteredConfig {
+	if self.tag != PolicyNodeFilteredOn {
+		panic("tag mismatch")
+	}
+	return self.value.(FilteredConfig)
+}
+func (self PolicyNode) AndThen() witTypes.Tuple2[int32, int32] {
+	if self.tag != PolicyNodeAndThen {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Tuple2[int32, int32])
+}
+func (self PolicyNode) PolicyUnion() witTypes.Tuple2[int32, int32] {
+	if self.tag != PolicyNodePolicyUnion {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Tuple2[int32, int32])
+}
+func (self PolicyNode) PolicyIntersect() witTypes.Tuple2[int32, int32] {
+	if self.tag != PolicyNodePolicyIntersect {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Tuple2[int32, int32])
+}
+
+func MakePolicyNodePeriodic(value uint64) PolicyNode {
+	return PolicyNode{PolicyNodePeriodic, value}
+}
+func MakePolicyNodeExponential(value ExponentialConfig) PolicyNode {
+	return PolicyNode{PolicyNodeExponential, value}
+}
+func MakePolicyNodeFibonacci(value FibonacciConfig) PolicyNode {
+	return PolicyNode{PolicyNodeFibonacci, value}
+}
+func MakePolicyNodeImmediate() PolicyNode {
+	return PolicyNode{PolicyNodeImmediate, nil}
+}
+func MakePolicyNodeNever() PolicyNode {
+	return PolicyNode{PolicyNodeNever, nil}
+}
+func MakePolicyNodeCountBox(value CountBoxConfig) PolicyNode {
+	return PolicyNode{PolicyNodeCountBox, value}
+}
+func MakePolicyNodeTimeBox(value TimeBoxConfig) PolicyNode {
+	return PolicyNode{PolicyNodeTimeBox, value}
+}
+func MakePolicyNodeClampDelay(value ClampConfig) PolicyNode {
+	return PolicyNode{PolicyNodeClampDelay, value}
+}
+func MakePolicyNodeAddDelay(value AddDelayConfig) PolicyNode {
+	return PolicyNode{PolicyNodeAddDelay, value}
+}
+func MakePolicyNodeJitter(value JitterConfig) PolicyNode {
+	return PolicyNode{PolicyNodeJitter, value}
+}
+func MakePolicyNodeFilteredOn(value FilteredConfig) PolicyNode {
+	return PolicyNode{PolicyNodeFilteredOn, value}
+}
+func MakePolicyNodeAndThen(value witTypes.Tuple2[int32, int32]) PolicyNode {
+	return PolicyNode{PolicyNodeAndThen, value}
+}
+func MakePolicyNodePolicyUnion(value witTypes.Tuple2[int32, int32]) PolicyNode {
+	return PolicyNode{PolicyNodePolicyUnion, value}
+}
+func MakePolicyNodePolicyIntersect(value witTypes.Tuple2[int32, int32]) PolicyNode {
+	return PolicyNode{PolicyNodePolicyIntersect, value}
+}
+
+// A composable retry policy tree.
+// Root is nodes[0]. Children referenced by policy-node-index.
+type RetryPolicy struct {
+	Nodes []PolicyNode
+}
+
+// ── Named policy rule ────────────────────────────────────────────
+// A named retry policy rule: predicate selects when it applies,
+// policy defines the retry strategy, priority controls evaluation order
+// (higher = checked first).
+type NamedRetryPolicy struct {
+	Name      string
+	Priority  uint32
+	Predicate RetryPredicate
+	Policy    RetryPolicy
+}
+
+//go:wasmimport golem:api/retry@1.5.0 get-retry-policies
+func wasm_import_get_retry_policies(arg0 uintptr)
+
+func GetRetryPolicies() []NamedRetryPolicy {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	wasm_import_get_retry_policies(returnArea)
+	result62 := make([]NamedRetryPolicy, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)))), index*(7*4))
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+		result28 := make([]PredicateNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))), index*(16+4*4))
+			var variant27 PredicateNode
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+				value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var variant PredicateValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+					value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+					variant = MakePredicateValueText(value1)
+
+				case 1:
+
+					variant = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				case 2:
+
+					variant = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+				default:
+					panic("unreachable")
+				}
+
+				variant27 = MakePredicateNodePropEq(PropertyComparison{value0, variant})
+
+			case 1:
+				value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var variant4 PredicateValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+					value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+					variant4 = MakePredicateValueText(value3)
+
+				case 1:
+
+					variant4 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				case 2:
+
+					variant4 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+				default:
+					panic("unreachable")
+				}
+
+				variant27 = MakePredicateNodePropNeq(PropertyComparison{value2, variant4})
+
+			case 2:
+				value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var variant7 PredicateValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+					value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+					variant7 = MakePredicateValueText(value6)
+
+				case 1:
+
+					variant7 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				case 2:
+
+					variant7 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+				default:
+					panic("unreachable")
+				}
+
+				variant27 = MakePredicateNodePropGt(PropertyComparison{value5, variant7})
+
+			case 3:
+				value8 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var variant10 PredicateValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+					value9 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+					variant10 = MakePredicateValueText(value9)
+
+				case 1:
+
+					variant10 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				case 2:
+
+					variant10 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+				default:
+					panic("unreachable")
+				}
+
+				variant27 = MakePredicateNodePropGte(PropertyComparison{value8, variant10})
+
+			case 4:
+				value11 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var variant13 PredicateValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+					value12 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+					variant13 = MakePredicateValueText(value12)
+
+				case 1:
+
+					variant13 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				case 2:
+
+					variant13 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+				default:
+					panic("unreachable")
+				}
+
+				variant27 = MakePredicateNodePropLt(PropertyComparison{value11, variant13})
+
+			case 5:
+				value14 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var variant16 PredicateValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+					value15 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+					variant16 = MakePredicateValueText(value15)
+
+				case 1:
+
+					variant16 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				case 2:
+
+					variant16 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+				default:
+					panic("unreachable")
+				}
+
+				variant27 = MakePredicateNodePropLte(PropertyComparison{value14, variant16})
+
+			case 6:
+				value17 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant27 = MakePredicateNodePropExists(value17)
+
+			case 7:
+				value18 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				result := make([]PredicateValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(8+2*4))
+					var variant20 PredicateValue
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+						value19 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant20 = MakePredicateValueText(value19)
+
+					case 1:
+
+						variant20 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 2:
+
+						variant20 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+					default:
+						panic("unreachable")
+					}
+
+					result = append(result, variant20)
+				}
+
+				variant27 = MakePredicateNodePropIn(PropertySetCheck{value18, result})
+
+			case 8:
+				value21 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				value22 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+				variant27 = MakePredicateNodePropMatches(PropertyPattern{value21, value22})
+
+			case 9:
+				value23 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				value24 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+				variant27 = MakePredicateNodePropStartsWith(PropertyPattern{value23, value24})
+
+			case 10:
+				value25 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				value26 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+				variant27 = MakePredicateNodePropContains(PropertyPattern{value25, value26})
+
+			case 11:
+
+				variant27 = MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 12:
+
+				variant27 = MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 13:
+
+				variant27 = MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 14:
+
+				variant27 = MakePredicateNodePredTrue()
+
+			case 15:
+
+				variant27 = MakePredicateNodePredFalse()
+
+			default:
+				panic("unreachable")
+			}
+
+			result28 = append(result28, variant27)
+		}
+
+		result61 := make([]PolicyNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))), index*32)
+			var variant60 PolicyNode
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+
+				variant60 = MakePolicyNodePeriodic(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 1:
+
+				variant60 = MakePolicyNodeExponential(ExponentialConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*float64)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+			case 2:
+
+				variant60 = MakePolicyNodeFibonacci(FibonacciConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+			case 3:
+
+				variant60 = MakePolicyNodeImmediate()
+
+			case 4:
+
+				variant60 = MakePolicyNodeNever()
+
+			case 5:
+
+				variant60 = MakePolicyNodeCountBox(CountBoxConfig{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 6:
+
+				variant60 = MakePolicyNodeTimeBox(TimeBoxConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+			case 7:
+
+				variant60 = MakePolicyNodeClampDelay(ClampConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 24))})
+
+			case 8:
+
+				variant60 = MakePolicyNodeAddDelay(AddDelayConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+			case 9:
+
+				variant60 = MakePolicyNodeJitter(JitterConfig{*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+			case 10:
+				result59 := make([]PredicateNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(16+4*4))
+					var variant58 PredicateNode
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+						value29 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant31 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value30 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant31 = MakePredicateValueText(value30)
+
+						case 1:
+
+							variant31 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant31 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant58 = MakePredicateNodePropEq(PropertyComparison{value29, variant31})
+
+					case 1:
+						value32 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant34 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value33 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant34 = MakePredicateValueText(value33)
+
+						case 1:
+
+							variant34 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant34 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant58 = MakePredicateNodePropNeq(PropertyComparison{value32, variant34})
+
+					case 2:
+						value35 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant37 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant37 = MakePredicateValueText(value36)
+
+						case 1:
+
+							variant37 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant37 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant58 = MakePredicateNodePropGt(PropertyComparison{value35, variant37})
+
+					case 3:
+						value38 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant40 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value39 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant40 = MakePredicateValueText(value39)
+
+						case 1:
+
+							variant40 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant40 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant58 = MakePredicateNodePropGte(PropertyComparison{value38, variant40})
+
+					case 4:
+						value41 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant43 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value42 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant43 = MakePredicateValueText(value42)
+
+						case 1:
+
+							variant43 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant43 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant58 = MakePredicateNodePropLt(PropertyComparison{value41, variant43})
+
+					case 5:
+						value44 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant46 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value45 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant46 = MakePredicateValueText(value45)
+
+						case 1:
+
+							variant46 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant46 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant58 = MakePredicateNodePropLte(PropertyComparison{value44, variant46})
+
+					case 6:
+						value47 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant58 = MakePredicateNodePropExists(value47)
+
+					case 7:
+						value48 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						result51 := make([]PredicateValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(8+2*4))
+							var variant50 PredicateValue
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value49 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant50 = MakePredicateValueText(value49)
+
+							case 1:
+
+								variant50 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+							case 2:
+
+								variant50 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+							default:
+								panic("unreachable")
+							}
+
+							result51 = append(result51, variant50)
+						}
+
+						variant58 = MakePredicateNodePropIn(PropertySetCheck{value48, result51})
+
+					case 8:
+						value52 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value53 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant58 = MakePredicateNodePropMatches(PropertyPattern{value52, value53})
+
+					case 9:
+						value54 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value55 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant58 = MakePredicateNodePropStartsWith(PropertyPattern{value54, value55})
+
+					case 10:
+						value56 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value57 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant58 = MakePredicateNodePropContains(PropertyPattern{value56, value57})
+
+					case 11:
+
+						variant58 = MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 12:
+
+						variant58 = MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 13:
+
+						variant58 = MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 14:
+
+						variant58 = MakePredicateNodePredTrue()
+
+					case 15:
+
+						variant58 = MakePredicateNodePredFalse()
+
+					default:
+						panic("unreachable")
+					}
+
+					result59 = append(result59, variant58)
+				}
+
+				variant60 = MakePolicyNodeFilteredOn(FilteredConfig{RetryPredicate{result59}, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+			case 11:
+
+				variant60 = MakePolicyNodeAndThen(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 12:
+
+				variant60 = MakePolicyNodePolicyUnion(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 13:
+
+				variant60 = MakePolicyNodePolicyIntersect(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			default:
+				panic("unreachable")
+			}
+
+			result61 = append(result61, variant60)
+		}
+
+		result62 = append(result62, NamedRetryPolicy{value, uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))), RetryPredicate{result28}, RetryPolicy{result61}})
+	}
+
+	result63 := result62
+	return result63
+
+}
+
+//go:wasmimport golem:api/retry@1.5.0 get-retry-policy-by-name
+func wasm_import_get_retry_policy_by_name(arg0 uintptr, arg1 uint32, arg2 uintptr)
+
+func GetRetryPolicyByName(name string) witTypes.Option[NamedRetryPolicy] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (8 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	wasm_import_get_retry_policy_by_name(uintptr(utf8), uint32(len(name)), returnArea)
+	var option witTypes.Option[NamedRetryPolicy]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[NamedRetryPolicy]()
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		result28 := make([]PredicateNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))), index*(16+4*4))
+			var variant27 PredicateNode
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+				value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var variant PredicateValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+					value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+					variant = MakePredicateValueText(value1)
+
+				case 1:
+
+					variant = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				case 2:
+
+					variant = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+				default:
+					panic("unreachable")
+				}
+
+				variant27 = MakePredicateNodePropEq(PropertyComparison{value0, variant})
+
+			case 1:
+				value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var variant4 PredicateValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+					value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+					variant4 = MakePredicateValueText(value3)
+
+				case 1:
+
+					variant4 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				case 2:
+
+					variant4 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+				default:
+					panic("unreachable")
+				}
+
+				variant27 = MakePredicateNodePropNeq(PropertyComparison{value2, variant4})
+
+			case 2:
+				value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var variant7 PredicateValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+					value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+					variant7 = MakePredicateValueText(value6)
+
+				case 1:
+
+					variant7 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				case 2:
+
+					variant7 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+				default:
+					panic("unreachable")
+				}
+
+				variant27 = MakePredicateNodePropGt(PropertyComparison{value5, variant7})
+
+			case 3:
+				value8 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var variant10 PredicateValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+					value9 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+					variant10 = MakePredicateValueText(value9)
+
+				case 1:
+
+					variant10 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				case 2:
+
+					variant10 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+				default:
+					panic("unreachable")
+				}
+
+				variant27 = MakePredicateNodePropGte(PropertyComparison{value8, variant10})
+
+			case 4:
+				value11 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var variant13 PredicateValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+					value12 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+					variant13 = MakePredicateValueText(value12)
+
+				case 1:
+
+					variant13 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				case 2:
+
+					variant13 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+				default:
+					panic("unreachable")
+				}
+
+				variant27 = MakePredicateNodePropLt(PropertyComparison{value11, variant13})
+
+			case 5:
+				value14 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var variant16 PredicateValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+					value15 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+					variant16 = MakePredicateValueText(value15)
+
+				case 1:
+
+					variant16 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				case 2:
+
+					variant16 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+				default:
+					panic("unreachable")
+				}
+
+				variant27 = MakePredicateNodePropLte(PropertyComparison{value14, variant16})
+
+			case 6:
+				value17 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant27 = MakePredicateNodePropExists(value17)
+
+			case 7:
+				value18 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				result := make([]PredicateValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(8+2*4))
+					var variant20 PredicateValue
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+						value19 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant20 = MakePredicateValueText(value19)
+
+					case 1:
+
+						variant20 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 2:
+
+						variant20 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+					default:
+						panic("unreachable")
+					}
+
+					result = append(result, variant20)
+				}
+
+				variant27 = MakePredicateNodePropIn(PropertySetCheck{value18, result})
+
+			case 8:
+				value21 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				value22 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+				variant27 = MakePredicateNodePropMatches(PropertyPattern{value21, value22})
+
+			case 9:
+				value23 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				value24 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+				variant27 = MakePredicateNodePropStartsWith(PropertyPattern{value23, value24})
+
+			case 10:
+				value25 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				value26 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+				variant27 = MakePredicateNodePropContains(PropertyPattern{value25, value26})
+
+			case 11:
+
+				variant27 = MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 12:
+
+				variant27 = MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 13:
+
+				variant27 = MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 14:
+
+				variant27 = MakePredicateNodePredTrue()
+
+			case 15:
+
+				variant27 = MakePredicateNodePredFalse()
+
+			default:
+				panic("unreachable")
+			}
+
+			result28 = append(result28, variant27)
+		}
+
+		result61 := make([]PolicyNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (7 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (7 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (6 * 4))))), index*32)
+			var variant60 PolicyNode
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+
+				variant60 = MakePolicyNodePeriodic(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 1:
+
+				variant60 = MakePolicyNodeExponential(ExponentialConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*float64)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+			case 2:
+
+				variant60 = MakePolicyNodeFibonacci(FibonacciConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+			case 3:
+
+				variant60 = MakePolicyNodeImmediate()
+
+			case 4:
+
+				variant60 = MakePolicyNodeNever()
+
+			case 5:
+
+				variant60 = MakePolicyNodeCountBox(CountBoxConfig{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 6:
+
+				variant60 = MakePolicyNodeTimeBox(TimeBoxConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+			case 7:
+
+				variant60 = MakePolicyNodeClampDelay(ClampConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 24))})
+
+			case 8:
+
+				variant60 = MakePolicyNodeAddDelay(AddDelayConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+			case 9:
+
+				variant60 = MakePolicyNodeJitter(JitterConfig{*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+			case 10:
+				result59 := make([]PredicateNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(16+4*4))
+					var variant58 PredicateNode
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+						value29 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant31 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value30 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant31 = MakePredicateValueText(value30)
+
+						case 1:
+
+							variant31 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant31 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant58 = MakePredicateNodePropEq(PropertyComparison{value29, variant31})
+
+					case 1:
+						value32 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant34 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value33 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant34 = MakePredicateValueText(value33)
+
+						case 1:
+
+							variant34 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant34 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant58 = MakePredicateNodePropNeq(PropertyComparison{value32, variant34})
+
+					case 2:
+						value35 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant37 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant37 = MakePredicateValueText(value36)
+
+						case 1:
+
+							variant37 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant37 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant58 = MakePredicateNodePropGt(PropertyComparison{value35, variant37})
+
+					case 3:
+						value38 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant40 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value39 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant40 = MakePredicateValueText(value39)
+
+						case 1:
+
+							variant40 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant40 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant58 = MakePredicateNodePropGte(PropertyComparison{value38, variant40})
+
+					case 4:
+						value41 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant43 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value42 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant43 = MakePredicateValueText(value42)
+
+						case 1:
+
+							variant43 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant43 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant58 = MakePredicateNodePropLt(PropertyComparison{value41, variant43})
+
+					case 5:
+						value44 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant46 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value45 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant46 = MakePredicateValueText(value45)
+
+						case 1:
+
+							variant46 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant46 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant58 = MakePredicateNodePropLte(PropertyComparison{value44, variant46})
+
+					case 6:
+						value47 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant58 = MakePredicateNodePropExists(value47)
+
+					case 7:
+						value48 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						result51 := make([]PredicateValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(8+2*4))
+							var variant50 PredicateValue
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value49 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant50 = MakePredicateValueText(value49)
+
+							case 1:
+
+								variant50 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+							case 2:
+
+								variant50 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+							default:
+								panic("unreachable")
+							}
+
+							result51 = append(result51, variant50)
+						}
+
+						variant58 = MakePredicateNodePropIn(PropertySetCheck{value48, result51})
+
+					case 8:
+						value52 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value53 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant58 = MakePredicateNodePropMatches(PropertyPattern{value52, value53})
+
+					case 9:
+						value54 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value55 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant58 = MakePredicateNodePropStartsWith(PropertyPattern{value54, value55})
+
+					case 10:
+						value56 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value57 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant58 = MakePredicateNodePropContains(PropertyPattern{value56, value57})
+
+					case 11:
+
+						variant58 = MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 12:
+
+						variant58 = MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 13:
+
+						variant58 = MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 14:
+
+						variant58 = MakePredicateNodePredTrue()
+
+					case 15:
+
+						variant58 = MakePredicateNodePredFalse()
+
+					default:
+						panic("unreachable")
+					}
+
+					result59 = append(result59, variant58)
+				}
+
+				variant60 = MakePolicyNodeFilteredOn(FilteredConfig{RetryPredicate{result59}, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+			case 11:
+
+				variant60 = MakePolicyNodeAndThen(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 12:
+
+				variant60 = MakePolicyNodePolicyUnion(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 13:
+
+				variant60 = MakePolicyNodePolicyIntersect(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			default:
+				panic("unreachable")
+			}
+
+			result61 = append(result61, variant60)
+		}
+
+		option = witTypes.Some[NamedRetryPolicy](NamedRetryPolicy{value, uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))), RetryPredicate{result28}, RetryPolicy{result61}})
+	default:
+		panic("unreachable")
+	}
+	result62 := option
+	return result62
+
+}
+
+//go:wasmimport golem:api/retry@1.5.0 resolve-retry-policy
+func wasm_import_resolve_retry_policy(arg0 uintptr, arg1 uint32, arg2 uintptr, arg3 uint32, arg4 uintptr, arg5 uint32, arg6 uintptr)
+
+func ResolveRetryPolicy(verb string, nounUri string, properties []witTypes.Tuple2[string, PredicateValue]) witTypes.Option[RetryPolicy] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(verb))
+	pinner.Pin(utf8)
+	utf80 := unsafe.Pointer(unsafe.StringData(nounUri))
+	pinner.Pin(utf80)
+	slice := properties
+	length := uint32(len(slice))
+	result3 := witRuntime.Allocate(pinner, uintptr(length*(8+4*4)), 8)
+	for index, element := range slice {
+		base := unsafe.Add(result3, index*(8+4*4))
+		utf81 := unsafe.Pointer(unsafe.StringData((element).F0))
+		pinner.Pin(utf81)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).F0)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf81)))
+
+		switch (element).F1.Tag() {
+		case PredicateValueText:
+			payload := (element).F1.Text()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+			utf82 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf82)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf82)))
+
+		case PredicateValueInteger:
+			payload := (element).F1.Integer()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = payload
+
+		case PredicateValueBoolean:
+			payload := (element).F1.Boolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(2))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(result)
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_resolve_retry_policy(uintptr(utf8), uint32(len(verb)), uintptr(utf80), uint32(len(nounUri)), uintptr(result3), length, returnArea)
+	var option witTypes.Option[RetryPolicy]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[RetryPolicy]()
+	case 1:
+		result34 := make([]PolicyNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*32)
+			var variant33 PolicyNode
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+
+				variant33 = MakePolicyNodePeriodic(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 1:
+
+				variant33 = MakePolicyNodeExponential(ExponentialConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*float64)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+			case 2:
+
+				variant33 = MakePolicyNodeFibonacci(FibonacciConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+			case 3:
+
+				variant33 = MakePolicyNodeImmediate()
+
+			case 4:
+
+				variant33 = MakePolicyNodeNever()
+
+			case 5:
+
+				variant33 = MakePolicyNodeCountBox(CountBoxConfig{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 6:
+
+				variant33 = MakePolicyNodeTimeBox(TimeBoxConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+			case 7:
+
+				variant33 = MakePolicyNodeClampDelay(ClampConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 24))})
+
+			case 8:
+
+				variant33 = MakePolicyNodeAddDelay(AddDelayConfig{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+			case 9:
+
+				variant33 = MakePolicyNodeJitter(JitterConfig{*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+			case 10:
+				result32 := make([]PredicateNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(16+4*4))
+					var variant31 PredicateNode
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+						value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant = MakePredicateValueText(value4)
+
+						case 1:
+
+							variant = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant31 = MakePredicateNodePropEq(PropertyComparison{value, variant})
+
+					case 1:
+						value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant7 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant7 = MakePredicateValueText(value6)
+
+						case 1:
+
+							variant7 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant7 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant31 = MakePredicateNodePropNeq(PropertyComparison{value5, variant7})
+
+					case 2:
+						value8 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant10 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value9 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant10 = MakePredicateValueText(value9)
+
+						case 1:
+
+							variant10 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant10 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant31 = MakePredicateNodePropGt(PropertyComparison{value8, variant10})
+
+					case 3:
+						value11 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant13 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value12 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant13 = MakePredicateValueText(value12)
+
+						case 1:
+
+							variant13 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant13 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant31 = MakePredicateNodePropGte(PropertyComparison{value11, variant13})
+
+					case 4:
+						value14 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant16 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value15 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant16 = MakePredicateValueText(value15)
+
+						case 1:
+
+							variant16 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant16 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant31 = MakePredicateNodePropLt(PropertyComparison{value14, variant16})
+
+					case 5:
+						value17 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						var variant19 PredicateValue
+						switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+						case 0:
+							value18 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))))
+
+							variant19 = MakePredicateValueText(value18)
+
+						case 1:
+
+							variant19 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+						case 2:
+
+							variant19 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0))
+
+						default:
+							panic("unreachable")
+						}
+
+						variant31 = MakePredicateNodePropLte(PropertyComparison{value17, variant19})
+
+					case 6:
+						value20 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant31 = MakePredicateNodePropExists(value20)
+
+					case 7:
+						value21 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						result24 := make([]PredicateValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+						for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+							base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(8+2*4))
+							var variant23 PredicateValue
+							switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+							case 0:
+								value22 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+								variant23 = MakePredicateValueText(value22)
+
+							case 1:
+
+								variant23 = MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+							case 2:
+
+								variant23 = MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+							default:
+								panic("unreachable")
+							}
+
+							result24 = append(result24, variant23)
+						}
+
+						variant31 = MakePredicateNodePropIn(PropertySetCheck{value21, result24})
+
+					case 8:
+						value25 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value26 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant31 = MakePredicateNodePropMatches(PropertyPattern{value25, value26})
+
+					case 9:
+						value27 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant31 = MakePredicateNodePropStartsWith(PropertyPattern{value27, value28})
+
+					case 10:
+						value29 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+						value30 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+						variant31 = MakePredicateNodePropContains(PropertyPattern{value29, value30})
+
+					case 11:
+
+						variant31 = MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 12:
+
+						variant31 = MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+					case 13:
+
+						variant31 = MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 14:
+
+						variant31 = MakePredicateNodePredTrue()
+
+					case 15:
+
+						variant31 = MakePredicateNodePredFalse()
+
+					default:
+						panic("unreachable")
+					}
+
+					result32 = append(result32, variant31)
+				}
+
+				variant33 = MakePolicyNodeFilteredOn(FilteredConfig{RetryPredicate{result32}, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+			case 11:
+
+				variant33 = MakePolicyNodeAndThen(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 12:
+
+				variant33 = MakePolicyNodePolicyUnion(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			case 13:
+
+				variant33 = MakePolicyNodePolicyIntersect(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+			default:
+				panic("unreachable")
+			}
+
+			result34 = append(result34, variant33)
+		}
+
+		option = witTypes.Some[RetryPolicy](RetryPolicy{result34})
+	default:
+		panic("unreachable")
+	}
+	result35 := option
+	return result35
+
+}
+
+//go:wasmimport golem:api/retry@1.5.0 set-retry-policy
+func wasm_import_set_retry_policy(arg0 uintptr, arg1 uint32, arg2 int32, arg3 uintptr, arg4 uint32, arg5 uintptr, arg6 uint32)
+
+func SetRetryPolicy(policy NamedRetryPolicy) {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData((policy).Name))
+	pinner.Pin(utf8)
+	slice28 := ((policy).Predicate).Nodes
+	length30 := uint32(len(slice28))
+	result29 := witRuntime.Allocate(pinner, uintptr(length30*(16+4*4)), 8)
+	for index, element := range slice28 {
+		base := unsafe.Add(result29, index*(16+4*4))
+
+		switch element.Tag() {
+		case PredicateNodePropEq:
+			payload := element.PropEq()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			utf80 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+			switch (payload).Value.Tag() {
+			case PredicateValueText:
+				payload := (payload).Value.Text()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+				utf81 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf81)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf81)))
+
+			case PredicateValueInteger:
+				payload := (payload).Value.Integer()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+			case PredicateValueBoolean:
+				payload := (payload).Value.Boolean()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+				var result int32
+				if payload {
+					result = 1
+				} else {
+					result = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result)
+
+			default:
+				panic("unreachable")
+			}
+
+		case PredicateNodePropNeq:
+			payload := element.PropNeq()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			utf82 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+			pinner.Pin(utf82)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf82)))
+
+			switch (payload).Value.Tag() {
+			case PredicateValueText:
+				payload := (payload).Value.Text()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+				utf83 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf83)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf83)))
+
+			case PredicateValueInteger:
+				payload := (payload).Value.Integer()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+			case PredicateValueBoolean:
+				payload := (payload).Value.Boolean()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+				var result4 int32
+				if payload {
+					result4 = 1
+				} else {
+					result4 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result4)
+
+			default:
+				panic("unreachable")
+			}
+
+		case PredicateNodePropGt:
+			payload := element.PropGt()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			utf85 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+			pinner.Pin(utf85)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf85)))
+
+			switch (payload).Value.Tag() {
+			case PredicateValueText:
+				payload := (payload).Value.Text()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+				utf86 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf86)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf86)))
+
+			case PredicateValueInteger:
+				payload := (payload).Value.Integer()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+			case PredicateValueBoolean:
+				payload := (payload).Value.Boolean()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+				var result7 int32
+				if payload {
+					result7 = 1
+				} else {
+					result7 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result7)
+
+			default:
+				panic("unreachable")
+			}
+
+		case PredicateNodePropGte:
+			payload := element.PropGte()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			utf88 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+			pinner.Pin(utf88)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf88)))
+
+			switch (payload).Value.Tag() {
+			case PredicateValueText:
+				payload := (payload).Value.Text()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+				utf89 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf89)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf89)))
+
+			case PredicateValueInteger:
+				payload := (payload).Value.Integer()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+			case PredicateValueBoolean:
+				payload := (payload).Value.Boolean()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+				var result10 int32
+				if payload {
+					result10 = 1
+				} else {
+					result10 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result10)
+
+			default:
+				panic("unreachable")
+			}
+
+		case PredicateNodePropLt:
+			payload := element.PropLt()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			utf811 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+			pinner.Pin(utf811)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf811)))
+
+			switch (payload).Value.Tag() {
+			case PredicateValueText:
+				payload := (payload).Value.Text()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+				utf812 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf812)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf812)))
+
+			case PredicateValueInteger:
+				payload := (payload).Value.Integer()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+			case PredicateValueBoolean:
+				payload := (payload).Value.Boolean()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+				var result13 int32
+				if payload {
+					result13 = 1
+				} else {
+					result13 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result13)
+
+			default:
+				panic("unreachable")
+			}
+
+		case PredicateNodePropLte:
+			payload := element.PropLte()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			utf814 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+			pinner.Pin(utf814)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf814)))
+
+			switch (payload).Value.Tag() {
+			case PredicateValueText:
+				payload := (payload).Value.Text()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+				utf815 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf815)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf815)))
+
+			case PredicateValueInteger:
+				payload := (payload).Value.Integer()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+			case PredicateValueBoolean:
+				payload := (payload).Value.Boolean()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+				var result16 int32
+				if payload {
+					result16 = 1
+				} else {
+					result16 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result16)
+
+			default:
+				panic("unreachable")
+			}
+
+		case PredicateNodePropExists:
+			payload := element.PropExists()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			utf817 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf817)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf817)))
+
+		case PredicateNodePropIn:
+			payload := element.PropIn()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			utf818 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+			pinner.Pin(utf818)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf818)))
+			slice := (payload).Values
+			length := uint32(len(slice))
+			result21 := witRuntime.Allocate(pinner, uintptr(length*(8+2*4)), 8)
+			for index, element := range slice {
+				base := unsafe.Add(result21, index*(8+2*4))
+
+				switch element.Tag() {
+				case PredicateValueText:
+					payload := element.Text()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+					utf819 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf819)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf819)))
+
+				case PredicateValueInteger:
+					payload := element.Integer()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+				case PredicateValueBoolean:
+					payload := element.Boolean()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+					var result20 int32
+					if payload {
+						result20 = 1
+					} else {
+						result20 = 0
+					}
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result20)
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result21)))
+
+		case PredicateNodePropMatches:
+			payload := element.PropMatches()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			utf822 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+			pinner.Pin(utf822)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf822)))
+			utf823 := unsafe.Pointer(unsafe.StringData((payload).Pattern))
+			pinner.Pin(utf823)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Pattern)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf823)))
+
+		case PredicateNodePropStartsWith:
+			payload := element.PropStartsWith()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			utf824 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+			pinner.Pin(utf824)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf824)))
+			utf825 := unsafe.Pointer(unsafe.StringData((payload).Pattern))
+			pinner.Pin(utf825)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Pattern)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf825)))
+
+		case PredicateNodePropContains:
+			payload := element.PropContains()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			utf826 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+			pinner.Pin(utf826)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf826)))
+			utf827 := unsafe.Pointer(unsafe.StringData((payload).Pattern))
+			pinner.Pin(utf827)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Pattern)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf827)))
+
+		case PredicateNodePredAnd:
+			payload := element.PredAnd()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).F1
+
+		case PredicateNodePredOr:
+			payload := element.PredOr()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).F1
+
+		case PredicateNodePredNot:
+			payload := element.PredNot()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case PredicateNodePredTrue:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+
+		case PredicateNodePredFalse:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	slice65 := ((policy).Policy).Nodes
+	length67 := uint32(len(slice65))
+	result66 := witRuntime.Allocate(pinner, uintptr(length67*32), 8)
+	for index, element := range slice65 {
+		base := unsafe.Add(result66, index*32)
+
+		switch element.Tag() {
+		case PolicyNodePeriodic:
+			payload := element.Periodic()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case PolicyNodeExponential:
+			payload := element.Exponential()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).BaseDelay)
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Factor
+
+		case PolicyNodeFibonacci:
+			payload := element.Fibonacci()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).First)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).Second)
+
+		case PolicyNodeImmediate:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+		case PolicyNodeNever:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+		case PolicyNodeCountBox:
+			payload := element.CountBox()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).MaxRetries)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Inner
+
+		case PolicyNodeTimeBox:
+			payload := element.TimeBox()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).Limit)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Inner
+
+		case PolicyNodeClampDelay:
+			payload := element.ClampDelay()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).MinDelay)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).MaxDelay)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Inner
+
+		case PolicyNodeAddDelay:
+			payload := element.AddDelay()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).Delay)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Inner
+
+		case PolicyNodeJitter:
+			payload := element.Jitter()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Factor
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Inner
+
+		case PolicyNodeFilteredOn:
+			payload := element.FilteredOn()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			slice62 := ((payload).Predicate).Nodes
+			length64 := uint32(len(slice62))
+			result63 := witRuntime.Allocate(pinner, uintptr(length64*(16+4*4)), 8)
+			for index, element := range slice62 {
+				base := unsafe.Add(result63, index*(16+4*4))
+
+				switch element.Tag() {
+				case PredicateNodePropEq:
+					payload := element.PropEq()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+					utf831 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf831)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf831)))
+
+					switch (payload).Value.Tag() {
+					case PredicateValueText:
+						payload := (payload).Value.Text()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+						utf832 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf832)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf832)))
+
+					case PredicateValueInteger:
+						payload := (payload).Value.Integer()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+					case PredicateValueBoolean:
+						payload := (payload).Value.Boolean()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+						var result33 int32
+						if payload {
+							result33 = 1
+						} else {
+							result33 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result33)
+
+					default:
+						panic("unreachable")
+					}
+
+				case PredicateNodePropNeq:
+					payload := element.PropNeq()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+					utf834 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf834)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf834)))
+
+					switch (payload).Value.Tag() {
+					case PredicateValueText:
+						payload := (payload).Value.Text()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+						utf835 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf835)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf835)))
+
+					case PredicateValueInteger:
+						payload := (payload).Value.Integer()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+					case PredicateValueBoolean:
+						payload := (payload).Value.Boolean()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+						var result36 int32
+						if payload {
+							result36 = 1
+						} else {
+							result36 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result36)
+
+					default:
+						panic("unreachable")
+					}
+
+				case PredicateNodePropGt:
+					payload := element.PropGt()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+					utf837 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf837)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf837)))
+
+					switch (payload).Value.Tag() {
+					case PredicateValueText:
+						payload := (payload).Value.Text()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+						utf838 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf838)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf838)))
+
+					case PredicateValueInteger:
+						payload := (payload).Value.Integer()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+					case PredicateValueBoolean:
+						payload := (payload).Value.Boolean()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+						var result39 int32
+						if payload {
+							result39 = 1
+						} else {
+							result39 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result39)
+
+					default:
+						panic("unreachable")
+					}
+
+				case PredicateNodePropGte:
+					payload := element.PropGte()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+					utf840 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf840)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf840)))
+
+					switch (payload).Value.Tag() {
+					case PredicateValueText:
+						payload := (payload).Value.Text()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+						utf841 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf841)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf841)))
+
+					case PredicateValueInteger:
+						payload := (payload).Value.Integer()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+					case PredicateValueBoolean:
+						payload := (payload).Value.Boolean()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+						var result42 int32
+						if payload {
+							result42 = 1
+						} else {
+							result42 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result42)
+
+					default:
+						panic("unreachable")
+					}
+
+				case PredicateNodePropLt:
+					payload := element.PropLt()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+					utf843 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf843)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf843)))
+
+					switch (payload).Value.Tag() {
+					case PredicateValueText:
+						payload := (payload).Value.Text()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+						utf844 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf844)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf844)))
+
+					case PredicateValueInteger:
+						payload := (payload).Value.Integer()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+					case PredicateValueBoolean:
+						payload := (payload).Value.Boolean()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+						var result45 int32
+						if payload {
+							result45 = 1
+						} else {
+							result45 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result45)
+
+					default:
+						panic("unreachable")
+					}
+
+				case PredicateNodePropLte:
+					payload := element.PropLte()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+					utf846 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf846)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf846)))
+
+					switch (payload).Value.Tag() {
+					case PredicateValueText:
+						payload := (payload).Value.Text()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+						utf847 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf847)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uintptr(uintptr(utf847)))
+
+					case PredicateValueInteger:
+						payload := (payload).Value.Integer()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = payload
+
+					case PredicateValueBoolean:
+						payload := (payload).Value.Boolean()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+						var result48 int32
+						if payload {
+							result48 = 1
+						} else {
+							result48 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(result48)
+
+					default:
+						panic("unreachable")
+					}
+
+				case PredicateNodePropExists:
+					payload := element.PropExists()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+					utf849 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf849)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf849)))
+
+				case PredicateNodePropIn:
+					payload := element.PropIn()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+					utf850 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf850)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf850)))
+					slice53 := (payload).Values
+					length55 := uint32(len(slice53))
+					result54 := witRuntime.Allocate(pinner, uintptr(length55*(8+2*4)), 8)
+					for index, element := range slice53 {
+						base := unsafe.Add(result54, index*(8+2*4))
+
+						switch element.Tag() {
+						case PredicateValueText:
+							payload := element.Text()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+							utf851 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf851)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf851)))
+
+						case PredicateValueInteger:
+							payload := element.Integer()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+						case PredicateValueBoolean:
+							payload := element.Boolean()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+							var result52 int32
+							if payload {
+								result52 = 1
+							} else {
+								result52 = 0
+							}
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result52)
+
+						default:
+							panic("unreachable")
+						}
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length55)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result54)))
+
+				case PredicateNodePropMatches:
+					payload := element.PropMatches()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+					utf856 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf856)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf856)))
+					utf857 := unsafe.Pointer(unsafe.StringData((payload).Pattern))
+					pinner.Pin(utf857)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Pattern)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf857)))
+
+				case PredicateNodePropStartsWith:
+					payload := element.PropStartsWith()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+					utf858 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf858)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf858)))
+					utf859 := unsafe.Pointer(unsafe.StringData((payload).Pattern))
+					pinner.Pin(utf859)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Pattern)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf859)))
+
+				case PredicateNodePropContains:
+					payload := element.PropContains()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+					utf860 := unsafe.Pointer(unsafe.StringData((payload).PropertyName))
+					pinner.Pin(utf860)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).PropertyName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf860)))
+					utf861 := unsafe.Pointer(unsafe.StringData((payload).Pattern))
+					pinner.Pin(utf861)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Pattern)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf861)))
+
+				case PredicateNodePredAnd:
+					payload := element.PredAnd()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).F1
+
+				case PredicateNodePredOr:
+					payload := element.PredOr()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).F1
+
+				case PredicateNodePredNot:
+					payload := element.PredNot()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+				case PredicateNodePredTrue:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+
+				case PredicateNodePredFalse:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length64)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result63)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Inner
+
+		case PolicyNodeAndThen:
+			payload := element.AndThen()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).F1
+
+		case PolicyNodePolicyUnion:
+			payload := element.PolicyUnion()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).F1
+
+		case PolicyNodePolicyIntersect:
+			payload := element.PolicyIntersect()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).F1
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_set_retry_policy(uintptr(utf8), uint32(len((policy).Name)), int32((policy).Priority), uintptr(result29), length30, uintptr(result66), length67)
+
+}
+
+//go:wasmimport golem:api/retry@1.5.0 remove-retry-policy
+func wasm_import_remove_retry_policy(arg0 uintptr, arg1 uint32)
+
+func RemoveRetryPolicy(name string) {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	wasm_import_remove_retry_policy(uintptr(utf8), uint32(len(name)))
+
+}
diff --git a/sdks/go/golem/internal/wit/golem_api_save_snapshot/empty.s b/sdks/go/golem/internal/wit/golem_api_save_snapshot/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_api_save_snapshot/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_api_save_snapshot/wit_bindings.go b/sdks/go/golem/internal/wit/golem_api_save_snapshot/wit_bindings.go
new file mode 100644
index 0000000000..a7a542439b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_api_save_snapshot/wit_bindings.go
@@ -0,0 +1,38 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_api_save_snapshot
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_host"
+)
+
+type Snapshot = golem_api_host.Snapshot
diff --git a/sdks/go/golem/internal/wit/golem_core_types/empty.s b/sdks/go/golem/internal/wit/golem_core_types/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_core_types/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_core_types/wit_bindings.go b/sdks/go/golem/internal/wit/golem_core_types/wit_bindings.go
new file mode 100644
index 0000000000..19abacc6db
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_core_types/wit_bindings.go
@@ -0,0 +1,1476 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_core_types
+
+import (
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+// ============================================================
+// Carrier indices
+// ============================================================
+// Index into a `schema-graph`'s `type-nodes` list.
+type TypeNodeIndex = int32
+
+// Index into a `schema-value-tree`'s `value-nodes` list.
+type ValueNodeIndex = int32
+
+// Index into a `schema-graph`'s `defs` list.
+type DefIndex = int32
+
+// Stable, language-independent identifier for a named type definition.
+// Must be unique within the enclosing `schema-graph`. Conventional format
+// is a dot-separated namespace path (e.g., `"myapp.users.user"`). Each
+// SDK provides a default derivation rule (typically based on the local
+// language's type name); cross-language interop requires the same
+// `type-id` on every side, which users can pin via the SDK's `named`
+// attribute.
+type TypeId = string
+
+// ============================================================
+// Common embedded value types
+// ============================================================
+type Uuid struct {
+	HighBits uint64
+	LowBits  uint64
+}
+
+type Datetime struct {
+	// Seconds since the Unix epoch (UTC).
+	Seconds int64
+	// Nanoseconds since `seconds`, in `[0, 1_000_000_000)`.
+	Nanoseconds uint32
+}
+
+type EnvironmentId struct {
+	Uuid Uuid
+}
+
+// ============================================================
+// Platform identifiers
+// ============================================================
+//
+// Platform identifiers used by the schema-native surfaces. Keeping them
+// here lets migrated interfaces depend on a single core version.
+// Represents a Golem component
+type ComponentId struct {
+	Uuid Uuid
+}
+
+// Represents a Golem agent
+type AgentId struct {
+	// Identifies the component the agent belongs to
+	ComponentId ComponentId
+	// String representation of the agent ID (agent type and constructor parameters)
+	AgentId string
+}
+
+// Represents a Golem account
+type AccountId struct {
+	Uuid Uuid
+}
+
+// Represents a Golem permission card
+type CardId struct {
+	Uuid Uuid
+}
+
+// An index into the persistent log storing all performed operations of an agent
+type OplogIndex = uint64
+
+// A promise ID is a value that can be passed to an external Golem API to
+// complete that promise from an arbitrary external source, while Golem
+// agents can await for this completion.
+type PromiseId struct {
+	AgentId  AgentId
+	OplogIdx uint64
+}
+
+//go:wasmimport golem:core/types@2.0.0 [resource-drop]quota-token
+func resourceDropQuotaToken(handle int32)
+
+// ============================================================
+// Capability resources
+// ============================================================
+// An unforgeable capability granting the right to consume a named
+// resource. The handle is opaque: a guest can only obtain one from the
+// host (e.g. via `golem:quota`) and can never inspect or fabricate its
+// internal state. When carried in a `schema-value-tree` (see
+// `schema-value-node::quota-token-handle`) the handle is transferred by
+// ownership; the host converts it to/from its internal trusted
+// representation at the boundary.
+type QuotaToken struct {
+	handle *witRuntime.Handle
+}
+
+func (self *QuotaToken) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *QuotaToken) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *QuotaToken) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *QuotaToken) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropQuotaToken(handle)
+	}
+}
+
+func QuotaTokenFromOwnHandle(handleValue int32) *QuotaToken {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &QuotaToken{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropQuotaToken(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func QuotaTokenFromBorrowHandle(handleValue int32) *QuotaToken {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &QuotaToken{handle}
+}
+
+//go:wasmimport golem:core/types@2.0.0 [resource-drop]secret
+func resourceDropSecret(handle int32)
+
+// An unforgeable handle to sensitive material held by the runtime. The
+// handle is opaque to guests: components can pass it through schema values
+// and reveal it only through capability-gated host interfaces.
+type Secret struct {
+	handle *witRuntime.Handle
+}
+
+func (self *Secret) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *Secret) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *Secret) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *Secret) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropSecret(handle)
+	}
+}
+
+func SecretFromOwnHandle(handleValue int32) *Secret {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &Secret{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropSecret(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func SecretFromBorrowHandle(handleValue int32) *Secret {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &Secret{handle}
+}
+
+// A named type definition inside a `schema-graph`.
+//
+// The def itself does not carry metadata; metadata lives on the
+// referenced `schema-type-node` so there is one source of truth for
+// docs / aliases / examples / deprecation / role on each type.
+type SchemaTypeDef struct {
+	// Stable identifier; unique within the enclosing graph.
+	Id string
+	// Optional human-readable qualified name (display only).
+	Name witTypes.Option[string]
+	// Index into the enclosing graph's `type-nodes` for this def's body.
+	Body int32
+}
+
+const (
+	// `list<variant<…>>` whose elements are interchangeable modalities.
+	RoleMultimodal uint8 = 0
+	// `variant { inline: text, url: url }` ergonomic unstructured-text wrapper.
+	RoleUnstructuredText uint8 = 1
+	// `variant { inline: binary, url: url }` ergonomic unstructured-binary wrapper.
+	RoleUnstructuredBinary uint8 = 2
+	// Any other producer-defined role, preserved verbatim.
+	RoleOther uint8 = 3
+)
+
+// Open registry; unknown roles fall back to structural handling.
+type Role struct {
+	tag   uint8
+	value any
+}
+
+func (self Role) Tag() uint8 {
+	return self.tag
+}
+
+func (self Role) Other() string {
+	if self.tag != RoleOther {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+
+func MakeRoleMultimodal() Role {
+	return Role{RoleMultimodal, nil}
+}
+func MakeRoleUnstructuredText() Role {
+	return Role{RoleUnstructuredText, nil}
+}
+func MakeRoleUnstructuredBinary() Role {
+	return Role{RoleUnstructuredBinary, nil}
+}
+func MakeRoleOther(value string) Role {
+	return Role{RoleOther, value}
+}
+
+// Typed metadata envelope. Holds non-validation, non-rendering-critical
+// information (docs, aliases, examples, deprecation, role). Per-scalar
+// validation constraints live on the relevant scalar's typed substructure,
+// not here.
+type MetadataEnvelope struct {
+	Doc     witTypes.Option[string]
+	Aliases []string
+	// Canonical-encoded example values (JSON strings). Empty = no examples.
+	// Kept as strings so metadata is self-contained on the type side and
+	// does not have to cross-reference an accompanying value tree.
+	Examples []string
+	// Deprecation message; `none` means not deprecated.
+	Deprecated witTypes.Option[string]
+	// Optional role annotation tagging a type with a consumer-facing intent.
+	Role witTypes.Option[Role]
+}
+
+type NamedFieldType struct {
+	Name     string
+	Body     int32
+	Metadata MetadataEnvelope
+}
+
+type VariantCaseType struct {
+	Name     string
+	Payload  witTypes.Option[int32]
+	Metadata MetadataEnvelope
+}
+
+type FixedListSpec struct {
+	Element int32
+	Length  uint32
+}
+
+// Map key types are restricted to primitives. Enforced at schema
+// construction time, not by the WIT type itself.
+type MapSpec struct {
+	Key   int32
+	Value int32
+}
+
+type ResultSpec struct {
+	Ok  witTypes.Option[int32]
+	Err witTypes.Option[int32]
+}
+
+const (
+	NumericBoundSigned    uint8 = 0
+	NumericBoundUnsigned  uint8 = 1
+	NumericBoundFloatBits uint8 = 2
+)
+
+// --- Numeric restrictions ---
+// A numeric bound usable across every numeric representation. Float bounds
+// carry canonical IEEE-754 `f64` bits (NaN/inf rejected, -0.0 normalized);
+// comparisons decode the bits to `f64` and compare numerically.
+type NumericBound struct {
+	tag   uint8
+	value any
+}
+
+func (self NumericBound) Tag() uint8 {
+	return self.tag
+}
+
+func (self NumericBound) Signed() int64 {
+	if self.tag != NumericBoundSigned {
+		panic("tag mismatch")
+	}
+	return self.value.(int64)
+}
+func (self NumericBound) Unsigned() uint64 {
+	if self.tag != NumericBoundUnsigned {
+		panic("tag mismatch")
+	}
+	return self.value.(uint64)
+}
+func (self NumericBound) FloatBits() uint64 {
+	if self.tag != NumericBoundFloatBits {
+		panic("tag mismatch")
+	}
+	return self.value.(uint64)
+}
+
+func MakeNumericBoundSigned(value int64) NumericBound {
+	return NumericBound{NumericBoundSigned, value}
+}
+func MakeNumericBoundUnsigned(value uint64) NumericBound {
+	return NumericBound{NumericBoundUnsigned, value}
+}
+func MakeNumericBoundFloatBits(value uint64) NumericBound {
+	return NumericBound{NumericBoundFloatBits, value}
+}
+
+// Inline numeric refinement. `none` on a numeric type means unconstrained
+// (the common case). The empty restriction set is never encoded as `some`:
+// producers normalize it to `none`, decoders normalize a decoded empty to
+// `none`. `unit` is schema/help metadata only.
+type NumericRestrictions struct {
+	Min  witTypes.Option[NumericBound]
+	Max  witTypes.Option[NumericBound]
+	Unit witTypes.Option[string]
+}
+
+// --- Text / Binary restrictions ---
+type TextRestrictions struct {
+	// Optional set of allowed BCP-47 language codes. `none` = unrestricted.
+	Languages witTypes.Option[[]string]
+	MinLength witTypes.Option[uint32]
+	MaxLength witTypes.Option[uint32]
+	Regex     witTypes.Option[string]
+}
+
+type BinaryRestrictions struct {
+	// Optional set of allowed MIME types. `none` = unrestricted.
+	MimeTypes witTypes.Option[[]string]
+	MinBytes  witTypes.Option[uint32]
+	MaxBytes  witTypes.Option[uint32]
+}
+
+const (
+	PathDirectionInput  uint8 = 0
+	PathDirectionOutput uint8 = 1
+	PathDirectionInOut  uint8 = 2
+)
+
+// --- Path ---
+type PathDirection = uint8
+
+const (
+	PathKindFile      uint8 = 0
+	PathKindDirectory uint8 = 1
+	PathKindAny       uint8 = 2
+)
+
+type PathKind = uint8
+
+type PathSpec struct {
+	Direction         PathDirection
+	Kind              PathKind
+	AllowedMimeTypes  witTypes.Option[[]string]
+	AllowedExtensions witTypes.Option[[]string]
+}
+
+// --- URL ---
+type UrlRestrictions struct {
+	AllowedSchemes witTypes.Option[[]string]
+	AllowedHosts   witTypes.Option[[]string]
+}
+
+// --- Quantity ---
+// Fixed-point decimal value with unit: numeric value = `mantissa * 10^(-scale)`.
+// `unit` is a free-form string at the value level; the schema's
+// `quantity-spec` constrains the accepted set.
+type QuantityValue struct {
+	Mantissa int64
+	Scale    int32
+	Unit     string
+}
+
+type QuantitySpec struct {
+	// Canonical base unit (e.g., `"kg"`, `"m"`, `"s"`, `"B"`).
+	BaseUnit string
+	// Suffixes accepted on input and rendered on output (e.g., `["kg","g","mg"]`).
+	AllowedSuffixes []string
+	// Optional inclusive range, expressed in canonical fixed-point form.
+	Min witTypes.Option[QuantityValue]
+	Max witTypes.Option[QuantityValue]
+}
+
+type FieldDiscriminator struct {
+	FieldName string
+	// Optional required literal value for the field.
+	Literal witTypes.Option[string]
+}
+
+const (
+	// String value starts with this prefix (e.g. `"ssh://"`).
+	DiscriminatorRulePrefix uint8 = 0
+	// String value ends with this suffix (e.g. `".tar.gz"`).
+	DiscriminatorRuleSuffix uint8 = 1
+	// String value contains this substring.
+	DiscriminatorRuleContains uint8 = 2
+	// String value matches this anchored regex.
+	DiscriminatorRuleRegex uint8 = 3
+	// Record-shaped value where the named field is present, and — if
+	// `literal` is set — has the given literal string value. The common
+	// JSON-discriminated-object case (`{"kind":"circle",…}`) is
+	// `field-equals { field-name: "kind", literal: some("circle") }`.
+	DiscriminatorRuleFieldEquals uint8 = 4
+	// Record-shaped value where the named field is absent.
+	DiscriminatorRuleFieldAbsent uint8 = 5
+)
+
+// How the decoder identifies that a value belongs to a given union branch.
+type DiscriminatorRule struct {
+	tag   uint8
+	value any
+}
+
+func (self DiscriminatorRule) Tag() uint8 {
+	return self.tag
+}
+
+func (self DiscriminatorRule) Prefix() string {
+	if self.tag != DiscriminatorRulePrefix {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DiscriminatorRule) Suffix() string {
+	if self.tag != DiscriminatorRuleSuffix {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DiscriminatorRule) Contains() string {
+	if self.tag != DiscriminatorRuleContains {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DiscriminatorRule) Regex() string {
+	if self.tag != DiscriminatorRuleRegex {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DiscriminatorRule) FieldEquals() FieldDiscriminator {
+	if self.tag != DiscriminatorRuleFieldEquals {
+		panic("tag mismatch")
+	}
+	return self.value.(FieldDiscriminator)
+}
+func (self DiscriminatorRule) FieldAbsent() string {
+	if self.tag != DiscriminatorRuleFieldAbsent {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+
+func MakeDiscriminatorRulePrefix(value string) DiscriminatorRule {
+	return DiscriminatorRule{DiscriminatorRulePrefix, value}
+}
+func MakeDiscriminatorRuleSuffix(value string) DiscriminatorRule {
+	return DiscriminatorRule{DiscriminatorRuleSuffix, value}
+}
+func MakeDiscriminatorRuleContains(value string) DiscriminatorRule {
+	return DiscriminatorRule{DiscriminatorRuleContains, value}
+}
+func MakeDiscriminatorRuleRegex(value string) DiscriminatorRule {
+	return DiscriminatorRule{DiscriminatorRuleRegex, value}
+}
+func MakeDiscriminatorRuleFieldEquals(value FieldDiscriminator) DiscriminatorRule {
+	return DiscriminatorRule{DiscriminatorRuleFieldEquals, value}
+}
+func MakeDiscriminatorRuleFieldAbsent(value string) DiscriminatorRule {
+	return DiscriminatorRule{DiscriminatorRuleFieldAbsent, value}
+}
+
+type UnionBranch struct {
+	// Logical branch name. Carried in `union-value.tag` after the
+	// decoder resolves the branch; used by renderers, codegen, docs.
+	Tag string
+	// Branch body type. Any schema type compatible with the
+	// discriminator rule (see schema-construction validation above).
+	Body int32
+	// Rule the decoder uses to pick this branch from a raw value.
+	Discriminator DiscriminatorRule
+	Metadata      MetadataEnvelope
+}
+
+// --- Discriminated union ---
+//
+// Inferred-tag sum. Each branch declares a rule that the decoder uses to
+// identify values belonging to that branch from the raw underlying value.
+//
+// Rules enforced at schema-construction time:
+//   - branch `tag`s are unique within the union,
+//   - string-pattern discriminators (`prefix` / `suffix` / `contains` /
+//     `regex`) require a string-shaped branch body (`string-type`,
+//     `text-type`, `url-type`, `path-type`, or a `ref` resolving to one),
+//   - record-shaped discriminators (`field-equals` / `field-absent`)
+//     require a record-shaped branch body that declares the referenced
+//     field (with the matching literal type, if any),
+//   - the discriminator set must be unambiguous: no value matches more
+//     than one branch. Overlap is checked structurally where decidable
+//     (e.g., `prefix("a")` and `prefix("ab")` overlap) and best-effort
+//     for `regex`.
+type UnionSpec struct {
+	Branches []UnionBranch
+}
+
+// --- Capability nodes ---
+type SecretSpec struct {
+	// Revealed payload type carried by this secret handle.
+	Inner int32
+	// Optional categorisation (e.g., `"api-key"`, `"oauth-token"`).
+	Category witTypes.Option[string]
+}
+
+type QuotaTokenSpec struct {
+	// Resource name this token covers (e.g., declared in the agent manifest).
+	// `none` = any resource permitted.
+	ResourceName witTypes.Option[string]
+}
+
+const (
+	// --- Reference to a named definition in the same `schema-graph` ---
+	SchemaTypeBodyRefType uint8 = 0
+	// --- Primitives ---
+	SchemaTypeBodyBoolType   uint8 = 1
+	SchemaTypeBodyS8Type     uint8 = 2
+	SchemaTypeBodyS16Type    uint8 = 3
+	SchemaTypeBodyS32Type    uint8 = 4
+	SchemaTypeBodyS64Type    uint8 = 5
+	SchemaTypeBodyU8Type     uint8 = 6
+	SchemaTypeBodyU16Type    uint8 = 7
+	SchemaTypeBodyU32Type    uint8 = 8
+	SchemaTypeBodyU64Type    uint8 = 9
+	SchemaTypeBodyF32Type    uint8 = 10
+	SchemaTypeBodyF64Type    uint8 = 11
+	SchemaTypeBodyCharType   uint8 = 12
+	SchemaTypeBodyStringType uint8 = 13
+	// --- Structural composites ---
+	SchemaTypeBodyRecordType    uint8 = 14
+	SchemaTypeBodyVariantType   uint8 = 15
+	SchemaTypeBodyEnumType      uint8 = 16
+	SchemaTypeBodyFlagsType     uint8 = 17
+	SchemaTypeBodyTupleType     uint8 = 18
+	SchemaTypeBodyListType      uint8 = 19
+	SchemaTypeBodyFixedListType uint8 = 20
+	SchemaTypeBodyMapType       uint8 = 21
+	SchemaTypeBodyOptionType    uint8 = 22
+	SchemaTypeBodyResultType    uint8 = 23
+	// --- Rich semantic types ---
+	SchemaTypeBodyTextType     uint8 = 24
+	SchemaTypeBodyBinaryType   uint8 = 25
+	SchemaTypeBodyPathType     uint8 = 26
+	SchemaTypeBodyUrlType      uint8 = 27
+	SchemaTypeBodyDatetimeType uint8 = 28
+	SchemaTypeBodyDurationType uint8 = 29
+	SchemaTypeBodyQuantityType uint8 = 30
+	// --- Discriminated union (closed, inferred-tag) ---
+	SchemaTypeBodyUnionType uint8 = 31
+	// --- Capability nodes ---
+	SchemaTypeBodySecretType     uint8 = 32
+	SchemaTypeBodyQuotaTokenType uint8 = 33
+	// --- WASI P3 stubs (parseable only; no semantics yet) ---
+	SchemaTypeBodyFutureType uint8 = 34
+	SchemaTypeBodyStreamType uint8 = 35
+)
+
+// The structural body of a `schema-type-node`.
+//
+// Closed sum types come in two shapes that differ by how the decoder
+// learns which branch a value belongs to:
+//
+//   - `variant-type` is a **carried-tag** sum: the value explicitly
+//     carries its case (`variant-value.case` index). Zero-inference
+//     decoding. Natural mapping for language-level algebraic data types
+//     (Rust `enum`, Scala `sealed trait`, WIT `variant`, etc.).
+//
+//   - `union-type` is an **inferred-tag** sum: the value does not carry
+//     its tag. Each branch declares a `discriminator-rule` (prefix /
+//     suffix / contains / regex on string-shaped bodies, or
+//     field-equals / field-absent on record-shaped bodies) and the
+//     decoder picks the branch whose rule matches the raw value.
+//     Natural mapping for inputs where the producer writes an unadorned
+//     value (a URL whose scheme picks the handler, a JSON object whose
+//     `"kind"` field picks the variant, an MCP content block whose
+//     `"type"` field picks the part shape, …).
+type SchemaTypeBody struct {
+	tag   uint8
+	value any
+}
+
+func (self SchemaTypeBody) Tag() uint8 {
+	return self.tag
+}
+
+func (self SchemaTypeBody) RefType() int32 {
+	if self.tag != SchemaTypeBodyRefType {
+		panic("tag mismatch")
+	}
+	return self.value.(int32)
+}
+func (self SchemaTypeBody) S8Type() witTypes.Option[NumericRestrictions] {
+	if self.tag != SchemaTypeBodyS8Type {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[NumericRestrictions])
+}
+func (self SchemaTypeBody) S16Type() witTypes.Option[NumericRestrictions] {
+	if self.tag != SchemaTypeBodyS16Type {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[NumericRestrictions])
+}
+func (self SchemaTypeBody) S32Type() witTypes.Option[NumericRestrictions] {
+	if self.tag != SchemaTypeBodyS32Type {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[NumericRestrictions])
+}
+func (self SchemaTypeBody) S64Type() witTypes.Option[NumericRestrictions] {
+	if self.tag != SchemaTypeBodyS64Type {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[NumericRestrictions])
+}
+func (self SchemaTypeBody) U8Type() witTypes.Option[NumericRestrictions] {
+	if self.tag != SchemaTypeBodyU8Type {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[NumericRestrictions])
+}
+func (self SchemaTypeBody) U16Type() witTypes.Option[NumericRestrictions] {
+	if self.tag != SchemaTypeBodyU16Type {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[NumericRestrictions])
+}
+func (self SchemaTypeBody) U32Type() witTypes.Option[NumericRestrictions] {
+	if self.tag != SchemaTypeBodyU32Type {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[NumericRestrictions])
+}
+func (self SchemaTypeBody) U64Type() witTypes.Option[NumericRestrictions] {
+	if self.tag != SchemaTypeBodyU64Type {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[NumericRestrictions])
+}
+func (self SchemaTypeBody) F32Type() witTypes.Option[NumericRestrictions] {
+	if self.tag != SchemaTypeBodyF32Type {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[NumericRestrictions])
+}
+func (self SchemaTypeBody) F64Type() witTypes.Option[NumericRestrictions] {
+	if self.tag != SchemaTypeBodyF64Type {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[NumericRestrictions])
+}
+func (self SchemaTypeBody) RecordType() []NamedFieldType {
+	if self.tag != SchemaTypeBodyRecordType {
+		panic("tag mismatch")
+	}
+	return self.value.([]NamedFieldType)
+}
+func (self SchemaTypeBody) VariantType() []VariantCaseType {
+	if self.tag != SchemaTypeBodyVariantType {
+		panic("tag mismatch")
+	}
+	return self.value.([]VariantCaseType)
+}
+func (self SchemaTypeBody) EnumType() []string {
+	if self.tag != SchemaTypeBodyEnumType {
+		panic("tag mismatch")
+	}
+	return self.value.([]string)
+}
+func (self SchemaTypeBody) FlagsType() []string {
+	if self.tag != SchemaTypeBodyFlagsType {
+		panic("tag mismatch")
+	}
+	return self.value.([]string)
+}
+func (self SchemaTypeBody) TupleType() []int32 {
+	if self.tag != SchemaTypeBodyTupleType {
+		panic("tag mismatch")
+	}
+	return self.value.([]int32)
+}
+func (self SchemaTypeBody) ListType() int32 {
+	if self.tag != SchemaTypeBodyListType {
+		panic("tag mismatch")
+	}
+	return self.value.(int32)
+}
+func (self SchemaTypeBody) FixedListType() FixedListSpec {
+	if self.tag != SchemaTypeBodyFixedListType {
+		panic("tag mismatch")
+	}
+	return self.value.(FixedListSpec)
+}
+func (self SchemaTypeBody) MapType() MapSpec {
+	if self.tag != SchemaTypeBodyMapType {
+		panic("tag mismatch")
+	}
+	return self.value.(MapSpec)
+}
+func (self SchemaTypeBody) OptionType() int32 {
+	if self.tag != SchemaTypeBodyOptionType {
+		panic("tag mismatch")
+	}
+	return self.value.(int32)
+}
+func (self SchemaTypeBody) ResultType() ResultSpec {
+	if self.tag != SchemaTypeBodyResultType {
+		panic("tag mismatch")
+	}
+	return self.value.(ResultSpec)
+}
+func (self SchemaTypeBody) TextType() TextRestrictions {
+	if self.tag != SchemaTypeBodyTextType {
+		panic("tag mismatch")
+	}
+	return self.value.(TextRestrictions)
+}
+func (self SchemaTypeBody) BinaryType() BinaryRestrictions {
+	if self.tag != SchemaTypeBodyBinaryType {
+		panic("tag mismatch")
+	}
+	return self.value.(BinaryRestrictions)
+}
+func (self SchemaTypeBody) PathType() PathSpec {
+	if self.tag != SchemaTypeBodyPathType {
+		panic("tag mismatch")
+	}
+	return self.value.(PathSpec)
+}
+func (self SchemaTypeBody) UrlType() UrlRestrictions {
+	if self.tag != SchemaTypeBodyUrlType {
+		panic("tag mismatch")
+	}
+	return self.value.(UrlRestrictions)
+}
+func (self SchemaTypeBody) QuantityType() QuantitySpec {
+	if self.tag != SchemaTypeBodyQuantityType {
+		panic("tag mismatch")
+	}
+	return self.value.(QuantitySpec)
+}
+func (self SchemaTypeBody) UnionType() UnionSpec {
+	if self.tag != SchemaTypeBodyUnionType {
+		panic("tag mismatch")
+	}
+	return self.value.(UnionSpec)
+}
+func (self SchemaTypeBody) SecretType() SecretSpec {
+	if self.tag != SchemaTypeBodySecretType {
+		panic("tag mismatch")
+	}
+	return self.value.(SecretSpec)
+}
+func (self SchemaTypeBody) QuotaTokenType() QuotaTokenSpec {
+	if self.tag != SchemaTypeBodyQuotaTokenType {
+		panic("tag mismatch")
+	}
+	return self.value.(QuotaTokenSpec)
+}
+func (self SchemaTypeBody) FutureType() witTypes.Option[int32] {
+	if self.tag != SchemaTypeBodyFutureType {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[int32])
+}
+func (self SchemaTypeBody) StreamType() witTypes.Option[int32] {
+	if self.tag != SchemaTypeBodyStreamType {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[int32])
+}
+
+func MakeSchemaTypeBodyRefType(value int32) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyRefType, value}
+}
+func MakeSchemaTypeBodyBoolType() SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyBoolType, nil}
+}
+func MakeSchemaTypeBodyS8Type(value witTypes.Option[NumericRestrictions]) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyS8Type, value}
+}
+func MakeSchemaTypeBodyS16Type(value witTypes.Option[NumericRestrictions]) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyS16Type, value}
+}
+func MakeSchemaTypeBodyS32Type(value witTypes.Option[NumericRestrictions]) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyS32Type, value}
+}
+func MakeSchemaTypeBodyS64Type(value witTypes.Option[NumericRestrictions]) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyS64Type, value}
+}
+func MakeSchemaTypeBodyU8Type(value witTypes.Option[NumericRestrictions]) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyU8Type, value}
+}
+func MakeSchemaTypeBodyU16Type(value witTypes.Option[NumericRestrictions]) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyU16Type, value}
+}
+func MakeSchemaTypeBodyU32Type(value witTypes.Option[NumericRestrictions]) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyU32Type, value}
+}
+func MakeSchemaTypeBodyU64Type(value witTypes.Option[NumericRestrictions]) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyU64Type, value}
+}
+func MakeSchemaTypeBodyF32Type(value witTypes.Option[NumericRestrictions]) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyF32Type, value}
+}
+func MakeSchemaTypeBodyF64Type(value witTypes.Option[NumericRestrictions]) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyF64Type, value}
+}
+func MakeSchemaTypeBodyCharType() SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyCharType, nil}
+}
+func MakeSchemaTypeBodyStringType() SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyStringType, nil}
+}
+func MakeSchemaTypeBodyRecordType(value []NamedFieldType) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyRecordType, value}
+}
+func MakeSchemaTypeBodyVariantType(value []VariantCaseType) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyVariantType, value}
+}
+func MakeSchemaTypeBodyEnumType(value []string) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyEnumType, value}
+}
+func MakeSchemaTypeBodyFlagsType(value []string) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyFlagsType, value}
+}
+func MakeSchemaTypeBodyTupleType(value []int32) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyTupleType, value}
+}
+func MakeSchemaTypeBodyListType(value int32) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyListType, value}
+}
+func MakeSchemaTypeBodyFixedListType(value FixedListSpec) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyFixedListType, value}
+}
+func MakeSchemaTypeBodyMapType(value MapSpec) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyMapType, value}
+}
+func MakeSchemaTypeBodyOptionType(value int32) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyOptionType, value}
+}
+func MakeSchemaTypeBodyResultType(value ResultSpec) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyResultType, value}
+}
+func MakeSchemaTypeBodyTextType(value TextRestrictions) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyTextType, value}
+}
+func MakeSchemaTypeBodyBinaryType(value BinaryRestrictions) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyBinaryType, value}
+}
+func MakeSchemaTypeBodyPathType(value PathSpec) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyPathType, value}
+}
+func MakeSchemaTypeBodyUrlType(value UrlRestrictions) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyUrlType, value}
+}
+func MakeSchemaTypeBodyDatetimeType() SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyDatetimeType, nil}
+}
+func MakeSchemaTypeBodyDurationType() SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyDurationType, nil}
+}
+func MakeSchemaTypeBodyQuantityType(value QuantitySpec) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyQuantityType, value}
+}
+func MakeSchemaTypeBodyUnionType(value UnionSpec) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyUnionType, value}
+}
+func MakeSchemaTypeBodySecretType(value SecretSpec) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodySecretType, value}
+}
+func MakeSchemaTypeBodyQuotaTokenType(value QuotaTokenSpec) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyQuotaTokenType, value}
+}
+func MakeSchemaTypeBodyFutureType(value witTypes.Option[int32]) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyFutureType, value}
+}
+func MakeSchemaTypeBodyStreamType(value witTypes.Option[int32]) SchemaTypeBody {
+	return SchemaTypeBody{SchemaTypeBodyStreamType, value}
+}
+
+// ============================================================
+// Schema type
+// ============================================================
+// One node in a `schema-graph`. Carries the type body and a per-node
+// metadata envelope (docs, aliases, examples, deprecation, role).
+// Recursive positions reference other nodes (or named definitions) by
+// index inside the body.
+type SchemaTypeNode struct {
+	Body     SchemaTypeBody
+	Metadata MetadataEnvelope
+}
+
+// ============================================================
+// Schema graph (self-contained type carrier)
+// ============================================================
+// A self-contained schema graph. Anywhere a schema travels with a value
+// (typed pair, oplog `custom` payload, REST/RPC envelope, public oplog
+// rendering), the payload owns its own `schema-graph` — there is no
+// implicit external registry that consumers must look up.
+type SchemaGraph struct {
+	// All schema-type nodes used in this graph. Reachable from `root`
+	// directly (anonymous types) or transitively via `defs`.
+	TypeNodes []SchemaTypeNode
+	// Named type definitions in this graph. Indices into this list are
+	// the targets of `schema-type-node::ref-type`. Ordering is
+	// deterministic (sorted by `id`).
+	Defs []SchemaTypeDef
+	// Index into `type-nodes` of the root schema type.
+	Root int32
+}
+
+type VariantValuePayload struct {
+	Case    uint32
+	Payload witTypes.Option[int32]
+}
+
+type MapEntry struct {
+	Key   int32
+	Value int32
+}
+
+const (
+	ResultValuePayloadOkValue  uint8 = 0
+	ResultValuePayloadErrValue uint8 = 1
+)
+
+// Result payload: exactly one of `ok-value` / `err-value` is set. Each
+// inner option allows `result<_, _>` cases whose ok/err type is unit (no
+// payload).
+type ResultValuePayload struct {
+	tag   uint8
+	value any
+}
+
+func (self ResultValuePayload) Tag() uint8 {
+	return self.tag
+}
+
+func (self ResultValuePayload) OkValue() witTypes.Option[int32] {
+	if self.tag != ResultValuePayloadOkValue {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[int32])
+}
+func (self ResultValuePayload) ErrValue() witTypes.Option[int32] {
+	if self.tag != ResultValuePayloadErrValue {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[int32])
+}
+
+func MakeResultValuePayloadOkValue(value witTypes.Option[int32]) ResultValuePayload {
+	return ResultValuePayload{ResultValuePayloadOkValue, value}
+}
+func MakeResultValuePayloadErrValue(value witTypes.Option[int32]) ResultValuePayload {
+	return ResultValuePayload{ResultValuePayloadErrValue, value}
+}
+
+type TextValuePayload struct {
+	Text string
+	// BCP-47 language tag, when known.
+	Language witTypes.Option[string]
+}
+
+type BinaryValuePayload struct {
+	Bytes    []uint8
+	MimeType witTypes.Option[string]
+}
+
+// Signed duration as total nanoseconds.
+type DurationValuePayload struct {
+	Nanoseconds int64
+}
+
+type UnionValuePayload struct {
+	// Tag of the branch the decoder resolved, matching one of the
+	// `union-spec::branches[*].tag` values. Carried so receivers do not
+	// have to re-run discriminator rules to know which branch was
+	// matched; encoders must ensure it agrees with the body.
+	Tag string
+	// Underlying value. Its shape matches the resolved branch's body
+	// type and (by construction) satisfies the branch's discriminator
+	// rule.
+	Body int32
+}
+
+const (
+	// Primitives
+	SchemaValueNodeBoolValue   uint8 = 0
+	SchemaValueNodeS8Value     uint8 = 1
+	SchemaValueNodeS16Value    uint8 = 2
+	SchemaValueNodeS32Value    uint8 = 3
+	SchemaValueNodeS64Value    uint8 = 4
+	SchemaValueNodeU8Value     uint8 = 5
+	SchemaValueNodeU16Value    uint8 = 6
+	SchemaValueNodeU32Value    uint8 = 7
+	SchemaValueNodeU64Value    uint8 = 8
+	SchemaValueNodeF32Value    uint8 = 9
+	SchemaValueNodeF64Value    uint8 = 10
+	SchemaValueNodeCharValue   uint8 = 11
+	SchemaValueNodeStringValue uint8 = 12
+	// Structural composites
+	SchemaValueNodeRecordValue    uint8 = 13
+	SchemaValueNodeVariantValue   uint8 = 14
+	SchemaValueNodeEnumValue      uint8 = 15
+	SchemaValueNodeFlagsValue     uint8 = 16
+	SchemaValueNodeTupleValue     uint8 = 17
+	SchemaValueNodeListValue      uint8 = 18
+	SchemaValueNodeFixedListValue uint8 = 19
+	SchemaValueNodeMapValue       uint8 = 20
+	SchemaValueNodeOptionValue    uint8 = 21
+	SchemaValueNodeResultValue    uint8 = 22
+	// Rich semantic
+	SchemaValueNodeTextValue         uint8 = 23
+	SchemaValueNodeBinaryValue       uint8 = 24
+	SchemaValueNodePathValue         uint8 = 25
+	SchemaValueNodeUrlValue          uint8 = 26
+	SchemaValueNodeDatetimeValue     uint8 = 27
+	SchemaValueNodeDurationValue     uint8 = 28
+	SchemaValueNodeQuantityValueNode uint8 = 29
+	// Discriminated union: tag is matched against schema branches.
+	SchemaValueNodeUnionValue uint8 = 30
+	// Capability nodes
+	SchemaValueNodeSecretValue      uint8 = 31
+	SchemaValueNodeQuotaTokenHandle uint8 = 32
+)
+
+type SchemaValueNode struct {
+	tag   uint8
+	value any
+}
+
+func (self SchemaValueNode) Tag() uint8 {
+	return self.tag
+}
+
+func (self SchemaValueNode) BoolValue() bool {
+	if self.tag != SchemaValueNodeBoolValue {
+		panic("tag mismatch")
+	}
+	return self.value.(bool)
+}
+func (self SchemaValueNode) S8Value() int8 {
+	if self.tag != SchemaValueNodeS8Value {
+		panic("tag mismatch")
+	}
+	return self.value.(int8)
+}
+func (self SchemaValueNode) S16Value() int16 {
+	if self.tag != SchemaValueNodeS16Value {
+		panic("tag mismatch")
+	}
+	return self.value.(int16)
+}
+func (self SchemaValueNode) S32Value() int32 {
+	if self.tag != SchemaValueNodeS32Value {
+		panic("tag mismatch")
+	}
+	return self.value.(int32)
+}
+func (self SchemaValueNode) S64Value() int64 {
+	if self.tag != SchemaValueNodeS64Value {
+		panic("tag mismatch")
+	}
+	return self.value.(int64)
+}
+func (self SchemaValueNode) U8Value() uint8 {
+	if self.tag != SchemaValueNodeU8Value {
+		panic("tag mismatch")
+	}
+	return self.value.(uint8)
+}
+func (self SchemaValueNode) U16Value() uint16 {
+	if self.tag != SchemaValueNodeU16Value {
+		panic("tag mismatch")
+	}
+	return self.value.(uint16)
+}
+func (self SchemaValueNode) U32Value() uint32 {
+	if self.tag != SchemaValueNodeU32Value {
+		panic("tag mismatch")
+	}
+	return self.value.(uint32)
+}
+func (self SchemaValueNode) U64Value() uint64 {
+	if self.tag != SchemaValueNodeU64Value {
+		panic("tag mismatch")
+	}
+	return self.value.(uint64)
+}
+func (self SchemaValueNode) F32Value() float32 {
+	if self.tag != SchemaValueNodeF32Value {
+		panic("tag mismatch")
+	}
+	return self.value.(float32)
+}
+func (self SchemaValueNode) F64Value() float64 {
+	if self.tag != SchemaValueNodeF64Value {
+		panic("tag mismatch")
+	}
+	return self.value.(float64)
+}
+func (self SchemaValueNode) CharValue() rune {
+	if self.tag != SchemaValueNodeCharValue {
+		panic("tag mismatch")
+	}
+	return self.value.(rune)
+}
+func (self SchemaValueNode) StringValue() string {
+	if self.tag != SchemaValueNodeStringValue {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self SchemaValueNode) RecordValue() []int32 {
+	if self.tag != SchemaValueNodeRecordValue {
+		panic("tag mismatch")
+	}
+	return self.value.([]int32)
+}
+func (self SchemaValueNode) VariantValue() VariantValuePayload {
+	if self.tag != SchemaValueNodeVariantValue {
+		panic("tag mismatch")
+	}
+	return self.value.(VariantValuePayload)
+}
+func (self SchemaValueNode) EnumValue() uint32 {
+	if self.tag != SchemaValueNodeEnumValue {
+		panic("tag mismatch")
+	}
+	return self.value.(uint32)
+}
+func (self SchemaValueNode) FlagsValue() []bool {
+	if self.tag != SchemaValueNodeFlagsValue {
+		panic("tag mismatch")
+	}
+	return self.value.([]bool)
+}
+func (self SchemaValueNode) TupleValue() []int32 {
+	if self.tag != SchemaValueNodeTupleValue {
+		panic("tag mismatch")
+	}
+	return self.value.([]int32)
+}
+func (self SchemaValueNode) ListValue() []int32 {
+	if self.tag != SchemaValueNodeListValue {
+		panic("tag mismatch")
+	}
+	return self.value.([]int32)
+}
+func (self SchemaValueNode) FixedListValue() []int32 {
+	if self.tag != SchemaValueNodeFixedListValue {
+		panic("tag mismatch")
+	}
+	return self.value.([]int32)
+}
+func (self SchemaValueNode) MapValue() []MapEntry {
+	if self.tag != SchemaValueNodeMapValue {
+		panic("tag mismatch")
+	}
+	return self.value.([]MapEntry)
+}
+func (self SchemaValueNode) OptionValue() witTypes.Option[int32] {
+	if self.tag != SchemaValueNodeOptionValue {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[int32])
+}
+func (self SchemaValueNode) ResultValue() ResultValuePayload {
+	if self.tag != SchemaValueNodeResultValue {
+		panic("tag mismatch")
+	}
+	return self.value.(ResultValuePayload)
+}
+func (self SchemaValueNode) TextValue() TextValuePayload {
+	if self.tag != SchemaValueNodeTextValue {
+		panic("tag mismatch")
+	}
+	return self.value.(TextValuePayload)
+}
+func (self SchemaValueNode) BinaryValue() BinaryValuePayload {
+	if self.tag != SchemaValueNodeBinaryValue {
+		panic("tag mismatch")
+	}
+	return self.value.(BinaryValuePayload)
+}
+func (self SchemaValueNode) PathValue() string {
+	if self.tag != SchemaValueNodePathValue {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self SchemaValueNode) UrlValue() string {
+	if self.tag != SchemaValueNodeUrlValue {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self SchemaValueNode) DatetimeValue() Datetime {
+	if self.tag != SchemaValueNodeDatetimeValue {
+		panic("tag mismatch")
+	}
+	return self.value.(Datetime)
+}
+func (self SchemaValueNode) DurationValue() DurationValuePayload {
+	if self.tag != SchemaValueNodeDurationValue {
+		panic("tag mismatch")
+	}
+	return self.value.(DurationValuePayload)
+}
+func (self SchemaValueNode) QuantityValueNode() QuantityValue {
+	if self.tag != SchemaValueNodeQuantityValueNode {
+		panic("tag mismatch")
+	}
+	return self.value.(QuantityValue)
+}
+func (self SchemaValueNode) UnionValue() UnionValuePayload {
+	if self.tag != SchemaValueNodeUnionValue {
+		panic("tag mismatch")
+	}
+	return self.value.(UnionValuePayload)
+}
+func (self SchemaValueNode) SecretValue() *Secret {
+	if self.tag != SchemaValueNodeSecretValue {
+		panic("tag mismatch")
+	}
+	return self.value.(*Secret)
+}
+func (self SchemaValueNode) QuotaTokenHandle() *QuotaToken {
+	if self.tag != SchemaValueNodeQuotaTokenHandle {
+		panic("tag mismatch")
+	}
+	return self.value.(*QuotaToken)
+}
+
+func MakeSchemaValueNodeBoolValue(value bool) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeBoolValue, value}
+}
+func MakeSchemaValueNodeS8Value(value int8) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeS8Value, value}
+}
+func MakeSchemaValueNodeS16Value(value int16) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeS16Value, value}
+}
+func MakeSchemaValueNodeS32Value(value int32) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeS32Value, value}
+}
+func MakeSchemaValueNodeS64Value(value int64) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeS64Value, value}
+}
+func MakeSchemaValueNodeU8Value(value uint8) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeU8Value, value}
+}
+func MakeSchemaValueNodeU16Value(value uint16) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeU16Value, value}
+}
+func MakeSchemaValueNodeU32Value(value uint32) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeU32Value, value}
+}
+func MakeSchemaValueNodeU64Value(value uint64) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeU64Value, value}
+}
+func MakeSchemaValueNodeF32Value(value float32) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeF32Value, value}
+}
+func MakeSchemaValueNodeF64Value(value float64) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeF64Value, value}
+}
+func MakeSchemaValueNodeCharValue(value rune) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeCharValue, value}
+}
+func MakeSchemaValueNodeStringValue(value string) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeStringValue, value}
+}
+func MakeSchemaValueNodeRecordValue(value []int32) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeRecordValue, value}
+}
+func MakeSchemaValueNodeVariantValue(value VariantValuePayload) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeVariantValue, value}
+}
+func MakeSchemaValueNodeEnumValue(value uint32) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeEnumValue, value}
+}
+func MakeSchemaValueNodeFlagsValue(value []bool) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeFlagsValue, value}
+}
+func MakeSchemaValueNodeTupleValue(value []int32) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeTupleValue, value}
+}
+func MakeSchemaValueNodeListValue(value []int32) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeListValue, value}
+}
+func MakeSchemaValueNodeFixedListValue(value []int32) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeFixedListValue, value}
+}
+func MakeSchemaValueNodeMapValue(value []MapEntry) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeMapValue, value}
+}
+func MakeSchemaValueNodeOptionValue(value witTypes.Option[int32]) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeOptionValue, value}
+}
+func MakeSchemaValueNodeResultValue(value ResultValuePayload) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeResultValue, value}
+}
+func MakeSchemaValueNodeTextValue(value TextValuePayload) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeTextValue, value}
+}
+func MakeSchemaValueNodeBinaryValue(value BinaryValuePayload) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeBinaryValue, value}
+}
+func MakeSchemaValueNodePathValue(value string) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodePathValue, value}
+}
+func MakeSchemaValueNodeUrlValue(value string) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeUrlValue, value}
+}
+func MakeSchemaValueNodeDatetimeValue(value Datetime) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeDatetimeValue, value}
+}
+func MakeSchemaValueNodeDurationValue(value DurationValuePayload) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeDurationValue, value}
+}
+func MakeSchemaValueNodeQuantityValueNode(value QuantityValue) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeQuantityValueNode, value}
+}
+func MakeSchemaValueNodeUnionValue(value UnionValuePayload) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeUnionValue, value}
+}
+func MakeSchemaValueNodeSecretValue(value *Secret) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeSecretValue, value}
+}
+func MakeSchemaValueNodeQuotaTokenHandle(value *QuotaToken) SchemaValueNode {
+	return SchemaValueNode{SchemaValueNodeQuotaTokenHandle, value}
+}
+
+// ============================================================
+// Schema value (always paired with a schema-graph)
+// ============================================================
+// A flat schema-value tree. Always travels paired with a `schema-graph`
+// (see `typed-schema-value`). Indices refer to entries in `value-nodes`
+// within this same tree.
+//
+// The value tree is structurally driven by the schema: record-value
+// payload order matches the schema's field order, variant-value carries a
+// case index, enum-value carries a case index, union-value carries the
+// discriminator's literal tag. The value side does not redundantly carry
+// field names, case names, or named-ref identifiers — those come from the
+// schema.
+type SchemaValueTree struct {
+	ValueNodes []SchemaValueNode
+	Root       int32
+}
+
+// ============================================================
+// Wire carriers
+// ============================================================
+// A typed value: a self-contained schema graph paired with a value tree
+// built against that schema.
+type TypedSchemaValue struct {
+	Graph SchemaGraph
+	Value SchemaValueTree
+}
+
+//go:wasmimport golem:core/types@2.0.0 parse-uuid
+func wasm_import_parse_uuid(arg0 uintptr, arg1 uint32, arg2 uintptr)
+
+func ParseUuid(uuid string) witTypes.Result[Uuid, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 24, 8))
+	utf8 := unsafe.Pointer(unsafe.StringData(uuid))
+	pinner.Pin(utf8)
+	wasm_import_parse_uuid(uintptr(utf8), uint32(len(uuid)), returnArea)
+	var result witTypes.Result[Uuid, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[Uuid, string](Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)))})
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		result = witTypes.Err[Uuid, string](value)
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport golem:core/types@2.0.0 uuid-to-string
+func wasm_import_uuid_to_string(arg0 int64, arg1 int64, arg2 uintptr)
+
+func UuidToString(uuid Uuid) string {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	wasm_import_uuid_to_string(int64((uuid).HighBits), int64((uuid).LowBits), returnArea)
+	value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	result := value
+	return result
+
+}
diff --git a/sdks/go/golem/internal/wit/golem_durability_durability/empty.s b/sdks/go/golem/internal/wit/golem_durability_durability/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_durability_durability/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_durability_durability/wit_bindings.go b/sdks/go/golem/internal/wit/golem_durability_durability/wit_bindings.go
new file mode 100644
index 0000000000..7ec71fa39c
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_durability_durability/wit_bindings.go
@@ -0,0 +1,7151 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_durability_durability
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_host"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_oplog"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_system_clock"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type PersistenceLevel = golem_api_host.PersistenceLevel
+type OplogIndex = uint64
+type WrappedFunctionType = golem_api_oplog.WrappedFunctionType
+type Datetime = wasi_clocks_0_3_0_system_clock.Instant
+type TypedSchemaValue = golem_core_types.TypedSchemaValue
+type DurableFunctionType = golem_api_oplog.WrappedFunctionType
+
+// Represents the current durable execution state
+type DurableExecutionState struct {
+	// If true, the executor is in live mode, side-effects should be performed and persisted.
+	// If false, the executor is in replay mode, side-effects should be replayed from the persisted data.
+	IsLive bool
+	// The currently active persistence level
+	PersistenceLevel golem_api_host.PersistenceLevel
+}
+
+const (
+	OplogEntryVersionV1 uint8 = 0
+	OplogEntryVersionV2 uint8 = 1
+)
+
+// Represents the oplog entry version; this is for backward compatibility and most use cases should always use
+// (and expect) the latest version.
+type OplogEntryVersion = uint8
+
+// Represents a persisted durable function invocation. The `response` field
+// contains a value and its schema graph together, making the user-defined payload observable by external tools.
+type PersistedDurableFunctionInvocation struct {
+	// The timestamp of the invocation.
+	Timestamp wasi_clocks_0_3_0_system_clock.Instant
+	// The invoked function's unique name
+	FunctionName string
+	// Arbitrary structured value and schema graph describing the invocation's result
+	Response golem_core_types.TypedSchemaValue
+	// Type of the durable function invocation
+	FunctionType golem_api_oplog.WrappedFunctionType
+	// Oplog entry version
+	EntryVersion OplogEntryVersion
+}
+
+//go:wasmimport golem:durability/durability@1.5.0 observe-function-call
+func wasm_import_observe_function_call(arg0 uintptr, arg1 uint32, arg2 uintptr, arg3 uint32)
+
+func ObserveFunctionCall(iface string, function string) {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData(iface))
+	pinner.Pin(utf8)
+	utf80 := unsafe.Pointer(unsafe.StringData(function))
+	pinner.Pin(utf80)
+	wasm_import_observe_function_call(uintptr(utf8), uint32(len(iface)), uintptr(utf80), uint32(len(function)))
+
+}
+
+//go:wasmimport golem:durability/durability@1.5.0 begin-durable-function
+func wasm_import_begin_durable_function(arg0 int32, arg1 int32, arg2 int64) int64
+
+func BeginDurableFunction(functionType golem_api_oplog.WrappedFunctionType) uint64 {
+
+	var variant int32
+	var variant3 int32
+	var variant4 int64
+	switch functionType.Tag() {
+	case golem_api_oplog.WrappedFunctionTypeReadLocal:
+
+		variant = int32(0)
+		variant3 = 0
+		variant4 = 0
+
+	case golem_api_oplog.WrappedFunctionTypeWriteLocal:
+
+		variant = int32(1)
+		variant3 = 0
+		variant4 = 0
+
+	case golem_api_oplog.WrappedFunctionTypeReadRemote:
+
+		variant = int32(2)
+		variant3 = 0
+		variant4 = 0
+
+	case golem_api_oplog.WrappedFunctionTypeWriteRemote:
+
+		variant = int32(3)
+		variant3 = 0
+		variant4 = 0
+
+	case golem_api_oplog.WrappedFunctionTypeWriteRemoteBatched:
+		payload := functionType.WriteRemoteBatched()
+		var option int32
+		var option0 int64
+		switch payload.Tag() {
+		case witTypes.OptionNone:
+
+			option = int32(0)
+			option0 = 0
+		case witTypes.OptionSome:
+			payload := payload.Some()
+
+			option = int32(1)
+			option0 = int64(payload)
+		default:
+			panic("unreachable")
+		}
+
+		variant = int32(4)
+		variant3 = option
+		variant4 = option0
+
+	case golem_api_oplog.WrappedFunctionTypeWriteRemoteTransaction:
+		payload := functionType.WriteRemoteTransaction()
+		var option1 int32
+		var option2 int64
+		switch payload.Tag() {
+		case witTypes.OptionNone:
+
+			option1 = int32(0)
+			option2 = 0
+		case witTypes.OptionSome:
+			payload := payload.Some()
+
+			option1 = int32(1)
+			option2 = int64(payload)
+		default:
+			panic("unreachable")
+		}
+
+		variant = int32(5)
+		variant3 = option1
+		variant4 = option2
+
+	default:
+		panic("unreachable")
+	}
+	result := wasm_import_begin_durable_function(variant, variant3, variant4)
+	return uint64(result)
+
+}
+
+//go:wasmimport golem:durability/durability@1.5.0 end-durable-function
+func wasm_import_end_durable_function(arg0 int32, arg1 int32, arg2 int64, arg3 int64, arg4 int32)
+
+func EndDurableFunction(functionType golem_api_oplog.WrappedFunctionType, beginIndex uint64, forcedCommit bool) {
+
+	var variant int32
+	var variant3 int32
+	var variant4 int64
+	switch functionType.Tag() {
+	case golem_api_oplog.WrappedFunctionTypeReadLocal:
+
+		variant = int32(0)
+		variant3 = 0
+		variant4 = 0
+
+	case golem_api_oplog.WrappedFunctionTypeWriteLocal:
+
+		variant = int32(1)
+		variant3 = 0
+		variant4 = 0
+
+	case golem_api_oplog.WrappedFunctionTypeReadRemote:
+
+		variant = int32(2)
+		variant3 = 0
+		variant4 = 0
+
+	case golem_api_oplog.WrappedFunctionTypeWriteRemote:
+
+		variant = int32(3)
+		variant3 = 0
+		variant4 = 0
+
+	case golem_api_oplog.WrappedFunctionTypeWriteRemoteBatched:
+		payload := functionType.WriteRemoteBatched()
+		var option int32
+		var option0 int64
+		switch payload.Tag() {
+		case witTypes.OptionNone:
+
+			option = int32(0)
+			option0 = 0
+		case witTypes.OptionSome:
+			payload := payload.Some()
+
+			option = int32(1)
+			option0 = int64(payload)
+		default:
+			panic("unreachable")
+		}
+
+		variant = int32(4)
+		variant3 = option
+		variant4 = option0
+
+	case golem_api_oplog.WrappedFunctionTypeWriteRemoteTransaction:
+		payload := functionType.WriteRemoteTransaction()
+		var option1 int32
+		var option2 int64
+		switch payload.Tag() {
+		case witTypes.OptionNone:
+
+			option1 = int32(0)
+			option2 = 0
+		case witTypes.OptionSome:
+			payload := payload.Some()
+
+			option1 = int32(1)
+			option2 = int64(payload)
+		default:
+			panic("unreachable")
+		}
+
+		variant = int32(5)
+		variant3 = option1
+		variant4 = option2
+
+	default:
+		panic("unreachable")
+	}
+	var result int32
+	if forcedCommit {
+		result = 1
+	} else {
+		result = 0
+	}
+	wasm_import_end_durable_function(variant, variant3, variant4, int64(beginIndex), result)
+
+}
+
+//go:wasmimport golem:durability/durability@1.5.0 current-durable-execution-state
+func wasm_import_current_durable_execution_state(arg0 uintptr)
+
+func CurrentDurableExecutionState() DurableExecutionState {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 2, 1))
+	wasm_import_current_durable_execution_state(returnArea)
+	var variant golem_api_host.PersistenceLevel
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 1))) {
+	case 0:
+
+		variant = golem_api_host.MakePersistenceLevelPersistNothing()
+
+	case 1:
+
+		variant = golem_api_host.MakePersistenceLevelPersistRemoteSideEffects()
+
+	case 2:
+
+		variant = golem_api_host.MakePersistenceLevelSmart()
+
+	default:
+		panic("unreachable")
+	}
+	result := DurableExecutionState{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) != 0), variant}
+	return result
+
+}
+
+//go:wasmimport golem:durability/durability@1.5.0 persist-durable-function-invocation
+func wasm_import_persist_durable_function_invocation(arg0 uintptr)
+
+func PersistDurableFunctionInvocation(functionName string, request golem_core_types.TypedSchemaValue, response golem_core_types.TypedSchemaValue, functionType golem_api_oplog.WrappedFunctionType) {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (24 + 18*4), 8))
+	utf8 := unsafe.Pointer(unsafe.StringData(functionName))
+	pinner.Pin(utf8)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)) = uint32(uint32(len(functionName)))
+	*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = uint32(uintptr(uintptr(utf8)))
+	slice115 := ((request).Graph).TypeNodes
+	length117 := uint32(len(slice115))
+	result116 := witRuntime.Allocate(pinner, uintptr(length117*(56+22*4)), 8)
+	for index, element := range slice115 {
+		base := unsafe.Add(result116, index*(56+22*4))
+
+		switch (element).Body.Tag() {
+		case golem_core_types.SchemaTypeBodyRefType:
+			payload := (element).Body.RefType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaTypeBodyBoolType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+		case golem_core_types.SchemaTypeBodyS8Type:
+			payload := (element).Body.S8Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf80 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf80)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf80)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyS16Type:
+			payload := (element).Body.S16Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf81 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf81)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf81)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyS32Type:
+			payload := (element).Body.S32Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf82 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf82)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf82)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyS64Type:
+			payload := (element).Body.S64Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf83 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf83)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf83)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU8Type:
+			payload := (element).Body.U8Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf84 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf84)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf84)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU16Type:
+			payload := (element).Body.U16Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf85 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf85)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf85)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU32Type:
+			payload := (element).Body.U32Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf86 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf86)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf86)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU64Type:
+			payload := (element).Body.U64Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf87 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf87)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf87)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyF32Type:
+			payload := (element).Body.F32Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf88 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf88)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf88)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyF64Type:
+			payload := (element).Body.F64Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf89 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf89)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf89)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyCharType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+
+		case golem_core_types.SchemaTypeBodyStringType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+
+		case golem_core_types.SchemaTypeBodyRecordType:
+			payload := (element).Body.RecordType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			slice19 := payload
+			length21 := uint32(len(slice19))
+			result20 := witRuntime.Allocate(pinner, uintptr(length21*(17*4)), 4)
+			for index, element := range slice19 {
+				base := unsafe.Add(result20, index*(17*4))
+				utf810 := unsafe.Pointer(unsafe.StringData((element).Name))
+				pinner.Pin(utf810)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf810)))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+					utf811 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf811)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf811)))
+
+				default:
+					panic("unreachable")
+				}
+				slice := ((element).Metadata).Aliases
+				length := uint32(len(slice))
+				result := witRuntime.Allocate(pinner, uintptr(length*(2*4)), 4)
+				for index, element := range slice {
+					base := unsafe.Add(result, index*(2*4))
+					utf812 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf812)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf812)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result)))
+				slice14 := ((element).Metadata).Examples
+				length16 := uint32(len(slice14))
+				result15 := witRuntime.Allocate(pinner, uintptr(length16*(2*4)), 4)
+				for index, element := range slice14 {
+					base := unsafe.Add(result15, index*(2*4))
+					utf813 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf813)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf813)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = uint32(length16)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result15)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(1))
+					utf817 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf817)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf817)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(3))
+						utf818 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf818)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uintptr(uintptr(utf818)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length21)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result20)))
+
+		case golem_core_types.SchemaTypeBodyVariantType:
+			payload := (element).Body.VariantType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			slice34 := payload
+			length36 := uint32(len(slice34))
+			result35 := witRuntime.Allocate(pinner, uintptr(length36*(8+16*4)), 4)
+			for index, element := range slice34 {
+				base := unsafe.Add(result35, index*(8+16*4))
+				utf822 := unsafe.Pointer(unsafe.StringData((element).Name))
+				pinner.Pin(utf822)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf822)))
+
+				switch (element).Payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (element).Payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+					utf823 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf823)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf823)))
+
+				default:
+					panic("unreachable")
+				}
+				slice25 := ((element).Metadata).Aliases
+				length27 := uint32(len(slice25))
+				result26 := witRuntime.Allocate(pinner, uintptr(length27*(2*4)), 4)
+				for index, element := range slice25 {
+					base := unsafe.Add(result26, index*(2*4))
+					utf824 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf824)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf824)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length27)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result26)))
+				slice29 := ((element).Metadata).Examples
+				length31 := uint32(len(slice29))
+				result30 := witRuntime.Allocate(pinner, uintptr(length31*(2*4)), 4)
+				for index, element := range slice29 {
+					base := unsafe.Add(result30, index*(2*4))
+					utf828 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf828)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf828)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length31)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result30)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+					utf832 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf832)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf832)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+						utf833 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf833)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf833)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length36)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result35)))
+
+		case golem_core_types.SchemaTypeBodyEnumType:
+			payload := (element).Body.EnumType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			slice38 := payload
+			length40 := uint32(len(slice38))
+			result39 := witRuntime.Allocate(pinner, uintptr(length40*(2*4)), 4)
+			for index, element := range slice38 {
+				base := unsafe.Add(result39, index*(2*4))
+				utf837 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf837)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf837)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length40)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result39)))
+
+		case golem_core_types.SchemaTypeBodyFlagsType:
+			payload := (element).Body.FlagsType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			slice42 := payload
+			length44 := uint32(len(slice42))
+			result43 := witRuntime.Allocate(pinner, uintptr(length44*(2*4)), 4)
+			for index, element := range slice42 {
+				base := unsafe.Add(result43, index*(2*4))
+				utf841 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf841)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf841)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length44)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result43)))
+
+		case golem_core_types.SchemaTypeBodyTupleType:
+			payload := (element).Body.TupleType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			slice45 := payload
+			length47 := uint32(len(slice45))
+			result46 := witRuntime.Allocate(pinner, uintptr(length47*4), 4)
+			for index, element := range slice45 {
+				base := unsafe.Add(result46, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length47)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result46)))
+
+		case golem_core_types.SchemaTypeBodyListType:
+			payload := (element).Body.ListType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaTypeBodyFixedListType:
+			payload := (element).Body.FixedListType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Element
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Length)
+
+		case golem_core_types.SchemaTypeBodyMapType:
+			payload := (element).Body.MapType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Key
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Value
+
+		case golem_core_types.SchemaTypeBodyOptionType:
+			payload := (element).Body.OptionType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaTypeBodyResultType:
+			payload := (element).Body.ResultType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+			switch (payload).Ok.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Ok.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).Err.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Err.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyTextType:
+			payload := (element).Body.TextType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+			switch (payload).Languages.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Languages.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				slice49 := payload
+				length51 := uint32(len(slice49))
+				result50 := witRuntime.Allocate(pinner, uintptr(length51*(2*4)), 4)
+				for index, element := range slice49 {
+					base := unsafe.Add(result50, index*(2*4))
+					utf848 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf848)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf848)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length51)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result50)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MinLength.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MinLength.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MaxLength.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MaxLength.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).Regex.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Regex.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(1))
+				utf852 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf852)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = uint32(uintptr(uintptr(utf852)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyBinaryType:
+			payload := (element).Body.BinaryType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+
+			switch (payload).MimeTypes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MimeTypes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				slice54 := payload
+				length56 := uint32(len(slice54))
+				result55 := witRuntime.Allocate(pinner, uintptr(length56*(2*4)), 4)
+				for index, element := range slice54 {
+					base := unsafe.Add(result55, index*(2*4))
+					utf853 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf853)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf853)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length56)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result55)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MinBytes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MinBytes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MaxBytes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MaxBytes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyPathType:
+			payload := (element).Body.PathType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Direction))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Kind))
+
+			switch (payload).AllowedMimeTypes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedMimeTypes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+				slice58 := payload
+				length60 := uint32(len(slice58))
+				result59 := witRuntime.Allocate(pinner, uintptr(length60*(2*4)), 4)
+				for index, element := range slice58 {
+					base := unsafe.Add(result59, index*(2*4))
+					utf857 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf857)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf857)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length60)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result59)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).AllowedExtensions.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedExtensions.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+				slice62 := payload
+				length64 := uint32(len(slice62))
+				result63 := witRuntime.Allocate(pinner, uintptr(length64*(2*4)), 4)
+				for index, element := range slice62 {
+					base := unsafe.Add(result63, index*(2*4))
+					utf861 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf861)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf861)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length64)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result63)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyUrlType:
+			payload := (element).Body.UrlType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+
+			switch (payload).AllowedSchemes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedSchemes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				slice66 := payload
+				length68 := uint32(len(slice66))
+				result67 := witRuntime.Allocate(pinner, uintptr(length68*(2*4)), 4)
+				for index, element := range slice66 {
+					base := unsafe.Add(result67, index*(2*4))
+					utf865 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf865)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf865)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length68)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result67)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).AllowedHosts.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedHosts.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				slice70 := payload
+				length72 := uint32(len(slice70))
+				result71 := witRuntime.Allocate(pinner, uintptr(length72*(2*4)), 4)
+				for index, element := range slice70 {
+					base := unsafe.Add(result71, index*(2*4))
+					utf869 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf869)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf869)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(length72)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(result71)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyDatetimeType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+		case golem_core_types.SchemaTypeBodyDurationType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+		case golem_core_types.SchemaTypeBodyQuantityType:
+			payload := (element).Body.QuantityType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			utf873 := unsafe.Pointer(unsafe.StringData((payload).BaseUnit))
+			pinner.Pin(utf873)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).BaseUnit)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf873)))
+			slice75 := (payload).AllowedSuffixes
+			length77 := uint32(len(slice75))
+			result76 := witRuntime.Allocate(pinner, uintptr(length77*(2*4)), 4)
+			for index, element := range slice75 {
+				base := unsafe.Add(result76, index*(2*4))
+				utf874 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf874)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf874)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length77)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result76)))
+
+			switch (payload).Min.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Min.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))) = (payload).Mantissa
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = (payload).Scale
+				utf878 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+				pinner.Pin(utf878)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))) = uint32(uint32(len((payload).Unit)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uintptr(uintptr(utf878)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).Max.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Max.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))) = (payload).Mantissa
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))) = (payload).Scale
+				utf879 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+				pinner.Pin(utf879)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))) = uint32(uint32(len((payload).Unit)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4))) = uint32(uintptr(uintptr(utf879)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyUnionType:
+			payload := (element).Body.UnionType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			slice99 := (payload).Branches
+			length101 := uint32(len(slice99))
+			result100 := witRuntime.Allocate(pinner, uintptr(length101*(23*4)), 4)
+			for index, element := range slice99 {
+				base := unsafe.Add(result100, index*(23*4))
+				utf880 := unsafe.Pointer(unsafe.StringData((element).Tag))
+				pinner.Pin(utf880)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Tag)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf880)))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+				switch (element).Discriminator.Tag() {
+				case golem_core_types.DiscriminatorRulePrefix:
+					payload := (element).Discriminator.Prefix()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+					utf881 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf881)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf881)))
+
+				case golem_core_types.DiscriminatorRuleSuffix:
+					payload := (element).Discriminator.Suffix()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+					utf882 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf882)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf882)))
+
+				case golem_core_types.DiscriminatorRuleContains:
+					payload := (element).Discriminator.Contains()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(2))
+					utf883 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf883)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf883)))
+
+				case golem_core_types.DiscriminatorRuleRegex:
+					payload := (element).Discriminator.Regex()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(3))
+					utf884 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf884)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf884)))
+
+				case golem_core_types.DiscriminatorRuleFieldEquals:
+					payload := (element).Discriminator.FieldEquals()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(4))
+					utf885 := unsafe.Pointer(unsafe.StringData((payload).FieldName))
+					pinner.Pin(utf885)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((payload).FieldName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf885)))
+
+					switch (payload).Literal.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Literal.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+						utf886 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf886)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf886)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.DiscriminatorRuleFieldAbsent:
+					payload := (element).Discriminator.FieldAbsent()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(5))
+					utf887 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf887)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf887)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+					utf888 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf888)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(utf888)))
+
+				default:
+					panic("unreachable")
+				}
+				slice90 := ((element).Metadata).Aliases
+				length92 := uint32(len(slice90))
+				result91 := witRuntime.Allocate(pinner, uintptr(length92*(2*4)), 4)
+				for index, element := range slice90 {
+					base := unsafe.Add(result91, index*(2*4))
+					utf889 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf889)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf889)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(length92)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(result91)))
+				slice94 := ((element).Metadata).Examples
+				length96 := uint32(len(slice94))
+				result95 := witRuntime.Allocate(pinner, uintptr(length96*(2*4)), 4)
+				for index, element := range slice94 {
+					base := unsafe.Add(result95, index*(2*4))
+					utf893 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf893)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf893)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(length96)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(result95)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(1))
+					utf897 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf897)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf897)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(3))
+						utf898 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf898)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(utf898)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length101)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result100)))
+
+		case golem_core_types.SchemaTypeBodySecretType:
+			payload := (element).Body.SecretType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Inner
+
+			switch (payload).Category.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Category.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+				utf8102 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8102)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8102)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyQuotaTokenType:
+			payload := (element).Body.QuotaTokenType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+			switch (payload).ResourceName.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).ResourceName.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				utf8103 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8103)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf8103)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyFutureType:
+			payload := (element).Body.FutureType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyStreamType:
+			payload := (element).Body.StreamType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		default:
+			panic("unreachable")
+		}
+
+		switch ((element).Metadata).Doc.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Metadata).Doc.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(1))
+			utf8104 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8104)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4))) = uint32(uintptr(uintptr(utf8104)))
+
+		default:
+			panic("unreachable")
+		}
+		slice106 := ((element).Metadata).Aliases
+		length108 := uint32(len(slice106))
+		result107 := witRuntime.Allocate(pinner, uintptr(length108*(2*4)), 4)
+		for index, element := range slice106 {
+			base := unsafe.Add(result107, index*(2*4))
+			utf8105 := unsafe.Pointer(unsafe.StringData(element))
+			pinner.Pin(utf8105)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8105)))
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length108)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result107)))
+		slice110 := ((element).Metadata).Examples
+		length112 := uint32(len(slice110))
+		result111 := witRuntime.Allocate(pinner, uintptr(length112*(2*4)), 4)
+		for index, element := range slice110 {
+			base := unsafe.Add(result111, index*(2*4))
+			utf8109 := unsafe.Pointer(unsafe.StringData(element))
+			pinner.Pin(utf8109)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8109)))
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length112)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result111)))
+
+		switch ((element).Metadata).Deprecated.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Metadata).Deprecated.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(1))
+			utf8113 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8113)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4))) = uint32(uintptr(uintptr(utf8113)))
+
+		default:
+			panic("unreachable")
+		}
+
+		switch ((element).Metadata).Role.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Metadata).Role.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(1))
+
+			switch payload.Tag() {
+			case golem_core_types.RoleMultimodal:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(0))
+
+			case golem_core_types.RoleUnstructuredText:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(1))
+
+			case golem_core_types.RoleUnstructuredBinary:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(2))
+
+			case golem_core_types.RoleOther:
+				payload := payload.Other()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(3))
+				utf8114 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8114)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4))) = uint32(uintptr(uintptr(utf8114)))
+
+			default:
+				panic("unreachable")
+			}
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))) = uint32(length117)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))) = uint32(uintptr(uintptr(result116)))
+	slice120 := ((request).Graph).Defs
+	length122 := uint32(len(slice120))
+	result121 := witRuntime.Allocate(pinner, uintptr(length122*(6*4)), 4)
+	for index, element := range slice120 {
+		base := unsafe.Add(result121, index*(6*4))
+		utf8118 := unsafe.Pointer(unsafe.StringData((element).Id))
+		pinner.Pin(utf8118)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8118)))
+
+		switch (element).Name.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := (element).Name.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+			utf8119 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8119)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8119)))
+
+		default:
+			panic("unreachable")
+		}
+		*(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body
+
+	}
+
+	*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4))) = uint32(length122)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))) = uint32(uintptr(uintptr(result121)))
+	*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (6 * 4))) = ((request).Graph).Root
+	slice151 := ((request).Value).ValueNodes
+	length153 := uint32(len(slice151))
+	result152 := witRuntime.Allocate(pinner, uintptr(length153*(16+4*4)), 8)
+	for index, element := range slice151 {
+		base := unsafe.Add(result152, index*(16+4*4))
+
+		switch element.Tag() {
+		case golem_core_types.SchemaValueNodeBoolValue:
+			payload := element.BoolValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			var result123 int32
+			if payload {
+				result123 = 1
+			} else {
+				result123 = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result123)
+
+		case golem_core_types.SchemaValueNodeS8Value:
+			payload := element.S8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS16Value:
+			payload := element.S16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS32Value:
+			payload := element.S32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeS64Value:
+			payload := element.S64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeU8Value:
+			payload := element.U8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU16Value:
+			payload := element.U16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU32Value:
+			payload := element.U32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeU64Value:
+			payload := element.U64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case golem_core_types.SchemaValueNodeF32Value:
+			payload := element.F32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeF64Value:
+			payload := element.F64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeCharValue:
+			payload := element.CharValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeStringValue:
+			payload := element.StringValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			utf8124 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8124)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8124)))
+
+		case golem_core_types.SchemaValueNodeRecordValue:
+			payload := element.RecordValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			slice125 := payload
+			length127 := uint32(len(slice125))
+			result126 := witRuntime.Allocate(pinner, uintptr(length127*4), 4)
+			for index, element := range slice125 {
+				base := unsafe.Add(result126, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length127)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result126)))
+
+		case golem_core_types.SchemaValueNodeVariantValue:
+			payload := element.VariantValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).Case)
+
+			switch (payload).Payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeEnumValue:
+			payload := element.EnumValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeFlagsValue:
+			payload := element.FlagsValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			slice129 := payload
+			length131 := uint32(len(slice129))
+			result130 := witRuntime.Allocate(pinner, uintptr(length131*1), 1)
+			for index, element := range slice129 {
+				base := unsafe.Add(result130, index*1)
+				var result128 int32
+				if element {
+					result128 = 1
+				} else {
+					result128 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result128)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length131)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result130)))
+
+		case golem_core_types.SchemaValueNodeTupleValue:
+			payload := element.TupleValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			slice132 := payload
+			length134 := uint32(len(slice132))
+			result133 := witRuntime.Allocate(pinner, uintptr(length134*4), 4)
+			for index, element := range slice132 {
+				base := unsafe.Add(result133, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length134)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result133)))
+
+		case golem_core_types.SchemaValueNodeListValue:
+			payload := element.ListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			slice135 := payload
+			length137 := uint32(len(slice135))
+			result136 := witRuntime.Allocate(pinner, uintptr(length137*4), 4)
+			for index, element := range slice135 {
+				base := unsafe.Add(result136, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length137)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result136)))
+
+		case golem_core_types.SchemaValueNodeFixedListValue:
+			payload := element.FixedListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			slice138 := payload
+			length140 := uint32(len(slice138))
+			result139 := witRuntime.Allocate(pinner, uintptr(length140*4), 4)
+			for index, element := range slice138 {
+				base := unsafe.Add(result139, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length140)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result139)))
+
+		case golem_core_types.SchemaValueNodeMapValue:
+			payload := element.MapValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			slice141 := payload
+			length143 := uint32(len(slice141))
+			result142 := witRuntime.Allocate(pinner, uintptr(length143*8), 4)
+			for index, element := range slice141 {
+				base := unsafe.Add(result142, index*8)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).Key
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (element).Value
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length143)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result142)))
+
+		case golem_core_types.SchemaValueNodeOptionValue:
+			payload := element.OptionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeResultValue:
+			payload := element.ResultValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+
+			switch payload.Tag() {
+			case golem_core_types.ResultValuePayloadOkValue:
+				payload := payload.OkValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.ResultValuePayloadErrValue:
+				payload := payload.ErrValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeTextValue:
+			payload := element.TextValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+			utf8144 := unsafe.Pointer(unsafe.StringData((payload).Text))
+			pinner.Pin(utf8144)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8144)))
+
+			switch (payload).Language.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Language.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf8145 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8145)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8145)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeBinaryValue:
+			payload := element.BinaryValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+			data := unsafe.Pointer(unsafe.SliceData((payload).Bytes))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+			switch (payload).MimeType.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MimeType.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf8146 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8146)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8146)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodePathValue:
+			payload := element.PathValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			utf8147 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8147)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8147)))
+
+		case golem_core_types.SchemaValueNodeUrlValue:
+			payload := element.UrlValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			utf8148 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8148)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8148)))
+
+		case golem_core_types.SchemaValueNodeDatetimeValue:
+			payload := element.DatetimeValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = int32((payload).Nanoseconds)
+
+		case golem_core_types.SchemaValueNodeDurationValue:
+			payload := element.DurationValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Nanoseconds
+
+		case golem_core_types.SchemaValueNodeQuantityValueNode:
+			payload := element.QuantityValueNode()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Mantissa
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Scale
+			utf8149 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+			pinner.Pin(utf8149)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uint32(len((payload).Unit)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))) = uint32(uintptr(uintptr(utf8149)))
+
+		case golem_core_types.SchemaValueNodeUnionValue:
+			payload := element.UnionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			utf8150 := unsafe.Pointer(unsafe.StringData((payload).Tag))
+			pinner.Pin(utf8150)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8150)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Body
+
+		case golem_core_types.SchemaValueNodeSecretValue:
+			payload := element.SecretValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		case golem_core_types.SchemaValueNodeQuotaTokenHandle:
+			payload := element.QuotaTokenHandle()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 * 4))) = uint32(length153)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (7 * 4))) = uint32(uintptr(uintptr(result152)))
+	*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (9 * 4))) = ((request).Value).Root
+	slice272 := ((response).Graph).TypeNodes
+	length274 := uint32(len(slice272))
+	result273 := witRuntime.Allocate(pinner, uintptr(length274*(56+22*4)), 8)
+	for index, element := range slice272 {
+		base := unsafe.Add(result273, index*(56+22*4))
+
+		switch (element).Body.Tag() {
+		case golem_core_types.SchemaTypeBodyRefType:
+			payload := (element).Body.RefType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaTypeBodyBoolType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+		case golem_core_types.SchemaTypeBodyS8Type:
+			payload := (element).Body.S8Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf8154 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8154)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8154)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyS16Type:
+			payload := (element).Body.S16Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf8155 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8155)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8155)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyS32Type:
+			payload := (element).Body.S32Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf8156 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8156)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8156)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyS64Type:
+			payload := (element).Body.S64Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf8157 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8157)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8157)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU8Type:
+			payload := (element).Body.U8Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf8158 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8158)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8158)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU16Type:
+			payload := (element).Body.U16Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf8159 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8159)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8159)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU32Type:
+			payload := (element).Body.U32Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf8160 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8160)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8160)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU64Type:
+			payload := (element).Body.U64Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf8161 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8161)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8161)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyF32Type:
+			payload := (element).Body.F32Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf8162 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8162)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8162)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyF64Type:
+			payload := (element).Body.F64Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf8163 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8163)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8163)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyCharType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+
+		case golem_core_types.SchemaTypeBodyStringType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+
+		case golem_core_types.SchemaTypeBodyRecordType:
+			payload := (element).Body.RecordType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			slice176 := payload
+			length178 := uint32(len(slice176))
+			result177 := witRuntime.Allocate(pinner, uintptr(length178*(17*4)), 4)
+			for index, element := range slice176 {
+				base := unsafe.Add(result177, index*(17*4))
+				utf8164 := unsafe.Pointer(unsafe.StringData((element).Name))
+				pinner.Pin(utf8164)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8164)))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+					utf8165 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8165)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8165)))
+
+				default:
+					panic("unreachable")
+				}
+				slice167 := ((element).Metadata).Aliases
+				length169 := uint32(len(slice167))
+				result168 := witRuntime.Allocate(pinner, uintptr(length169*(2*4)), 4)
+				for index, element := range slice167 {
+					base := unsafe.Add(result168, index*(2*4))
+					utf8166 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8166)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8166)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length169)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result168)))
+				slice171 := ((element).Metadata).Examples
+				length173 := uint32(len(slice171))
+				result172 := witRuntime.Allocate(pinner, uintptr(length173*(2*4)), 4)
+				for index, element := range slice171 {
+					base := unsafe.Add(result172, index*(2*4))
+					utf8170 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8170)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8170)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = uint32(length173)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result172)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(1))
+					utf8174 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8174)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf8174)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(3))
+						utf8175 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8175)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uintptr(uintptr(utf8175)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length178)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result177)))
+
+		case golem_core_types.SchemaTypeBodyVariantType:
+			payload := (element).Body.VariantType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			slice191 := payload
+			length193 := uint32(len(slice191))
+			result192 := witRuntime.Allocate(pinner, uintptr(length193*(8+16*4)), 4)
+			for index, element := range slice191 {
+				base := unsafe.Add(result192, index*(8+16*4))
+				utf8179 := unsafe.Pointer(unsafe.StringData((element).Name))
+				pinner.Pin(utf8179)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8179)))
+
+				switch (element).Payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (element).Payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+					utf8180 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8180)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8180)))
+
+				default:
+					panic("unreachable")
+				}
+				slice182 := ((element).Metadata).Aliases
+				length184 := uint32(len(slice182))
+				result183 := witRuntime.Allocate(pinner, uintptr(length184*(2*4)), 4)
+				for index, element := range slice182 {
+					base := unsafe.Add(result183, index*(2*4))
+					utf8181 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8181)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8181)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length184)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result183)))
+				slice186 := ((element).Metadata).Examples
+				length188 := uint32(len(slice186))
+				result187 := witRuntime.Allocate(pinner, uintptr(length188*(2*4)), 4)
+				for index, element := range slice186 {
+					base := unsafe.Add(result187, index*(2*4))
+					utf8185 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8185)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8185)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length188)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result187)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+					utf8189 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8189)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf8189)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+						utf8190 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8190)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf8190)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length193)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result192)))
+
+		case golem_core_types.SchemaTypeBodyEnumType:
+			payload := (element).Body.EnumType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			slice195 := payload
+			length197 := uint32(len(slice195))
+			result196 := witRuntime.Allocate(pinner, uintptr(length197*(2*4)), 4)
+			for index, element := range slice195 {
+				base := unsafe.Add(result196, index*(2*4))
+				utf8194 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf8194)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8194)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length197)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result196)))
+
+		case golem_core_types.SchemaTypeBodyFlagsType:
+			payload := (element).Body.FlagsType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			slice199 := payload
+			length201 := uint32(len(slice199))
+			result200 := witRuntime.Allocate(pinner, uintptr(length201*(2*4)), 4)
+			for index, element := range slice199 {
+				base := unsafe.Add(result200, index*(2*4))
+				utf8198 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf8198)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8198)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length201)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result200)))
+
+		case golem_core_types.SchemaTypeBodyTupleType:
+			payload := (element).Body.TupleType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			slice202 := payload
+			length204 := uint32(len(slice202))
+			result203 := witRuntime.Allocate(pinner, uintptr(length204*4), 4)
+			for index, element := range slice202 {
+				base := unsafe.Add(result203, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length204)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result203)))
+
+		case golem_core_types.SchemaTypeBodyListType:
+			payload := (element).Body.ListType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaTypeBodyFixedListType:
+			payload := (element).Body.FixedListType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Element
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Length)
+
+		case golem_core_types.SchemaTypeBodyMapType:
+			payload := (element).Body.MapType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Key
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Value
+
+		case golem_core_types.SchemaTypeBodyOptionType:
+			payload := (element).Body.OptionType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaTypeBodyResultType:
+			payload := (element).Body.ResultType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+			switch (payload).Ok.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Ok.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).Err.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Err.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyTextType:
+			payload := (element).Body.TextType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+			switch (payload).Languages.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Languages.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				slice206 := payload
+				length208 := uint32(len(slice206))
+				result207 := witRuntime.Allocate(pinner, uintptr(length208*(2*4)), 4)
+				for index, element := range slice206 {
+					base := unsafe.Add(result207, index*(2*4))
+					utf8205 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8205)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8205)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length208)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result207)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MinLength.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MinLength.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MaxLength.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MaxLength.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).Regex.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Regex.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(1))
+				utf8209 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8209)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = uint32(uintptr(uintptr(utf8209)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyBinaryType:
+			payload := (element).Body.BinaryType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+
+			switch (payload).MimeTypes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MimeTypes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				slice211 := payload
+				length213 := uint32(len(slice211))
+				result212 := witRuntime.Allocate(pinner, uintptr(length213*(2*4)), 4)
+				for index, element := range slice211 {
+					base := unsafe.Add(result212, index*(2*4))
+					utf8210 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8210)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8210)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length213)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result212)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MinBytes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MinBytes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MaxBytes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MaxBytes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyPathType:
+			payload := (element).Body.PathType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Direction))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Kind))
+
+			switch (payload).AllowedMimeTypes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedMimeTypes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+				slice215 := payload
+				length217 := uint32(len(slice215))
+				result216 := witRuntime.Allocate(pinner, uintptr(length217*(2*4)), 4)
+				for index, element := range slice215 {
+					base := unsafe.Add(result216, index*(2*4))
+					utf8214 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8214)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8214)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length217)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result216)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).AllowedExtensions.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedExtensions.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+				slice219 := payload
+				length221 := uint32(len(slice219))
+				result220 := witRuntime.Allocate(pinner, uintptr(length221*(2*4)), 4)
+				for index, element := range slice219 {
+					base := unsafe.Add(result220, index*(2*4))
+					utf8218 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8218)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8218)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length221)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result220)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyUrlType:
+			payload := (element).Body.UrlType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+
+			switch (payload).AllowedSchemes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedSchemes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				slice223 := payload
+				length225 := uint32(len(slice223))
+				result224 := witRuntime.Allocate(pinner, uintptr(length225*(2*4)), 4)
+				for index, element := range slice223 {
+					base := unsafe.Add(result224, index*(2*4))
+					utf8222 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8222)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8222)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length225)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result224)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).AllowedHosts.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedHosts.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				slice227 := payload
+				length229 := uint32(len(slice227))
+				result228 := witRuntime.Allocate(pinner, uintptr(length229*(2*4)), 4)
+				for index, element := range slice227 {
+					base := unsafe.Add(result228, index*(2*4))
+					utf8226 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8226)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8226)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(length229)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(result228)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyDatetimeType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+		case golem_core_types.SchemaTypeBodyDurationType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+		case golem_core_types.SchemaTypeBodyQuantityType:
+			payload := (element).Body.QuantityType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			utf8230 := unsafe.Pointer(unsafe.StringData((payload).BaseUnit))
+			pinner.Pin(utf8230)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).BaseUnit)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8230)))
+			slice232 := (payload).AllowedSuffixes
+			length234 := uint32(len(slice232))
+			result233 := witRuntime.Allocate(pinner, uintptr(length234*(2*4)), 4)
+			for index, element := range slice232 {
+				base := unsafe.Add(result233, index*(2*4))
+				utf8231 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf8231)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8231)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length234)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result233)))
+
+			switch (payload).Min.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Min.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))) = (payload).Mantissa
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = (payload).Scale
+				utf8235 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+				pinner.Pin(utf8235)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))) = uint32(uint32(len((payload).Unit)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uintptr(uintptr(utf8235)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).Max.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Max.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))) = (payload).Mantissa
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))) = (payload).Scale
+				utf8236 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+				pinner.Pin(utf8236)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))) = uint32(uint32(len((payload).Unit)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4))) = uint32(uintptr(uintptr(utf8236)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyUnionType:
+			payload := (element).Body.UnionType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			slice256 := (payload).Branches
+			length258 := uint32(len(slice256))
+			result257 := witRuntime.Allocate(pinner, uintptr(length258*(23*4)), 4)
+			for index, element := range slice256 {
+				base := unsafe.Add(result257, index*(23*4))
+				utf8237 := unsafe.Pointer(unsafe.StringData((element).Tag))
+				pinner.Pin(utf8237)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Tag)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8237)))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+				switch (element).Discriminator.Tag() {
+				case golem_core_types.DiscriminatorRulePrefix:
+					payload := (element).Discriminator.Prefix()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+					utf8238 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8238)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8238)))
+
+				case golem_core_types.DiscriminatorRuleSuffix:
+					payload := (element).Discriminator.Suffix()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+					utf8239 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8239)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8239)))
+
+				case golem_core_types.DiscriminatorRuleContains:
+					payload := (element).Discriminator.Contains()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(2))
+					utf8240 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8240)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8240)))
+
+				case golem_core_types.DiscriminatorRuleRegex:
+					payload := (element).Discriminator.Regex()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(3))
+					utf8241 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8241)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8241)))
+
+				case golem_core_types.DiscriminatorRuleFieldEquals:
+					payload := (element).Discriminator.FieldEquals()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(4))
+					utf8242 := unsafe.Pointer(unsafe.StringData((payload).FieldName))
+					pinner.Pin(utf8242)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((payload).FieldName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8242)))
+
+					switch (payload).Literal.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Literal.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+						utf8243 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8243)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8243)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.DiscriminatorRuleFieldAbsent:
+					payload := (element).Discriminator.FieldAbsent()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(5))
+					utf8244 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8244)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8244)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+					utf8245 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8245)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(utf8245)))
+
+				default:
+					panic("unreachable")
+				}
+				slice247 := ((element).Metadata).Aliases
+				length249 := uint32(len(slice247))
+				result248 := witRuntime.Allocate(pinner, uintptr(length249*(2*4)), 4)
+				for index, element := range slice247 {
+					base := unsafe.Add(result248, index*(2*4))
+					utf8246 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8246)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8246)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(length249)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(result248)))
+				slice251 := ((element).Metadata).Examples
+				length253 := uint32(len(slice251))
+				result252 := witRuntime.Allocate(pinner, uintptr(length253*(2*4)), 4)
+				for index, element := range slice251 {
+					base := unsafe.Add(result252, index*(2*4))
+					utf8250 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8250)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8250)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(length253)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(result252)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(1))
+					utf8254 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8254)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf8254)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(3))
+						utf8255 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8255)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(utf8255)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length258)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result257)))
+
+		case golem_core_types.SchemaTypeBodySecretType:
+			payload := (element).Body.SecretType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Inner
+
+			switch (payload).Category.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Category.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+				utf8259 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8259)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8259)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyQuotaTokenType:
+			payload := (element).Body.QuotaTokenType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+			switch (payload).ResourceName.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).ResourceName.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				utf8260 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8260)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf8260)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyFutureType:
+			payload := (element).Body.FutureType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyStreamType:
+			payload := (element).Body.StreamType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		default:
+			panic("unreachable")
+		}
+
+		switch ((element).Metadata).Doc.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Metadata).Doc.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(1))
+			utf8261 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8261)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4))) = uint32(uintptr(uintptr(utf8261)))
+
+		default:
+			panic("unreachable")
+		}
+		slice263 := ((element).Metadata).Aliases
+		length265 := uint32(len(slice263))
+		result264 := witRuntime.Allocate(pinner, uintptr(length265*(2*4)), 4)
+		for index, element := range slice263 {
+			base := unsafe.Add(result264, index*(2*4))
+			utf8262 := unsafe.Pointer(unsafe.StringData(element))
+			pinner.Pin(utf8262)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8262)))
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length265)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result264)))
+		slice267 := ((element).Metadata).Examples
+		length269 := uint32(len(slice267))
+		result268 := witRuntime.Allocate(pinner, uintptr(length269*(2*4)), 4)
+		for index, element := range slice267 {
+			base := unsafe.Add(result268, index*(2*4))
+			utf8266 := unsafe.Pointer(unsafe.StringData(element))
+			pinner.Pin(utf8266)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8266)))
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length269)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result268)))
+
+		switch ((element).Metadata).Deprecated.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Metadata).Deprecated.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(1))
+			utf8270 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8270)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4))) = uint32(uintptr(uintptr(utf8270)))
+
+		default:
+			panic("unreachable")
+		}
+
+		switch ((element).Metadata).Role.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Metadata).Role.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(1))
+
+			switch payload.Tag() {
+			case golem_core_types.RoleMultimodal:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(0))
+
+			case golem_core_types.RoleUnstructuredText:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(1))
+
+			case golem_core_types.RoleUnstructuredBinary:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(2))
+
+			case golem_core_types.RoleOther:
+				payload := payload.Other()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(3))
+				utf8271 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8271)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4))) = uint32(uintptr(uintptr(utf8271)))
+
+			default:
+				panic("unreachable")
+			}
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (11 * 4))) = uint32(length274)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (10 * 4))) = uint32(uintptr(uintptr(result273)))
+	slice277 := ((response).Graph).Defs
+	length279 := uint32(len(slice277))
+	result278 := witRuntime.Allocate(pinner, uintptr(length279*(6*4)), 4)
+	for index, element := range slice277 {
+		base := unsafe.Add(result278, index*(6*4))
+		utf8275 := unsafe.Pointer(unsafe.StringData((element).Id))
+		pinner.Pin(utf8275)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8275)))
+
+		switch (element).Name.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := (element).Name.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+			utf8276 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8276)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8276)))
+
+		default:
+			panic("unreachable")
+		}
+		*(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body
+
+	}
+
+	*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (13 * 4))) = uint32(length279)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (12 * 4))) = uint32(uintptr(uintptr(result278)))
+	*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (14 * 4))) = ((response).Graph).Root
+	slice309 := ((response).Value).ValueNodes
+	length311 := uint32(len(slice309))
+	result310 := witRuntime.Allocate(pinner, uintptr(length311*(16+4*4)), 8)
+	for index, element := range slice309 {
+		base := unsafe.Add(result310, index*(16+4*4))
+
+		switch element.Tag() {
+		case golem_core_types.SchemaValueNodeBoolValue:
+			payload := element.BoolValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			var result280 int32
+			if payload {
+				result280 = 1
+			} else {
+				result280 = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result280)
+
+		case golem_core_types.SchemaValueNodeS8Value:
+			payload := element.S8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS16Value:
+			payload := element.S16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeS32Value:
+			payload := element.S32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeS64Value:
+			payload := element.S64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeU8Value:
+			payload := element.U8Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU16Value:
+			payload := element.U16Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case golem_core_types.SchemaValueNodeU32Value:
+			payload := element.U32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeU64Value:
+			payload := element.U64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case golem_core_types.SchemaValueNodeF32Value:
+			payload := element.F32Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeF64Value:
+			payload := element.F64Value()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaValueNodeCharValue:
+			payload := element.CharValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeStringValue:
+			payload := element.StringValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			utf8281 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8281)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8281)))
+
+		case golem_core_types.SchemaValueNodeRecordValue:
+			payload := element.RecordValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			slice282 := payload
+			length284 := uint32(len(slice282))
+			result283 := witRuntime.Allocate(pinner, uintptr(length284*4), 4)
+			for index, element := range slice282 {
+				base := unsafe.Add(result283, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length284)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result283)))
+
+		case golem_core_types.SchemaValueNodeVariantValue:
+			payload := element.VariantValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).Case)
+
+			switch (payload).Payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeEnumValue:
+			payload := element.EnumValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case golem_core_types.SchemaValueNodeFlagsValue:
+			payload := element.FlagsValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			slice286 := payload
+			length288 := uint32(len(slice286))
+			result287 := witRuntime.Allocate(pinner, uintptr(length288*1), 1)
+			for index, element := range slice286 {
+				base := unsafe.Add(result287, index*1)
+				var result285 int32
+				if element {
+					result285 = 1
+				} else {
+					result285 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result285)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length288)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result287)))
+
+		case golem_core_types.SchemaValueNodeTupleValue:
+			payload := element.TupleValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			slice289 := payload
+			length291 := uint32(len(slice289))
+			result290 := witRuntime.Allocate(pinner, uintptr(length291*4), 4)
+			for index, element := range slice289 {
+				base := unsafe.Add(result290, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length291)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result290)))
+
+		case golem_core_types.SchemaValueNodeListValue:
+			payload := element.ListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			slice292 := payload
+			length294 := uint32(len(slice292))
+			result293 := witRuntime.Allocate(pinner, uintptr(length294*4), 4)
+			for index, element := range slice292 {
+				base := unsafe.Add(result293, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length294)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result293)))
+
+		case golem_core_types.SchemaValueNodeFixedListValue:
+			payload := element.FixedListValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			slice295 := payload
+			length297 := uint32(len(slice295))
+			result296 := witRuntime.Allocate(pinner, uintptr(length297*4), 4)
+			for index, element := range slice295 {
+				base := unsafe.Add(result296, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length297)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result296)))
+
+		case golem_core_types.SchemaValueNodeMapValue:
+			payload := element.MapValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			slice298 := payload
+			length300 := uint32(len(slice298))
+			result299 := witRuntime.Allocate(pinner, uintptr(length300*8), 4)
+			for index, element := range slice298 {
+				base := unsafe.Add(result299, index*8)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).Key
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (element).Value
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length300)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result299)))
+
+		case golem_core_types.SchemaValueNodeOptionValue:
+			payload := element.OptionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeResultValue:
+			payload := element.ResultValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+
+			switch payload.Tag() {
+			case golem_core_types.ResultValuePayloadOkValue:
+				payload := payload.OkValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.ResultValuePayloadErrValue:
+				payload := payload.ErrValue()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeTextValue:
+			payload := element.TextValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+			utf8301 := unsafe.Pointer(unsafe.StringData((payload).Text))
+			pinner.Pin(utf8301)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8301)))
+
+			switch (payload).Language.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Language.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf8302 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8302)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8302)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodeBinaryValue:
+			payload := element.BinaryValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+			data303 := unsafe.Pointer(unsafe.SliceData((payload).Bytes))
+			pinner.Pin(data303)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data303)))
+
+			switch (payload).MimeType.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MimeType.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf8304 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8304)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8304)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaValueNodePathValue:
+			payload := element.PathValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			utf8305 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8305)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8305)))
+
+		case golem_core_types.SchemaValueNodeUrlValue:
+			payload := element.UrlValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			utf8306 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8306)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8306)))
+
+		case golem_core_types.SchemaValueNodeDatetimeValue:
+			payload := element.DatetimeValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Seconds
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = int32((payload).Nanoseconds)
+
+		case golem_core_types.SchemaValueNodeDurationValue:
+			payload := element.DurationValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Nanoseconds
+
+		case golem_core_types.SchemaValueNodeQuantityValueNode:
+			payload := element.QuantityValueNode()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Mantissa
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Scale
+			utf8307 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+			pinner.Pin(utf8307)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uint32(len((payload).Unit)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))) = uint32(uintptr(uintptr(utf8307)))
+
+		case golem_core_types.SchemaValueNodeUnionValue:
+			payload := element.UnionValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			utf8308 := unsafe.Pointer(unsafe.StringData((payload).Tag))
+			pinner.Pin(utf8308)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8308)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Body
+
+		case golem_core_types.SchemaValueNodeSecretValue:
+			payload := element.SecretValue()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		case golem_core_types.SchemaValueNodeQuotaTokenHandle:
+			payload := element.QuotaTokenHandle()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 * 4))) = uint32(length311)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (15 * 4))) = uint32(uintptr(uintptr(result310)))
+	*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (17 * 4))) = ((response).Value).Root
+
+	switch functionType.Tag() {
+	case golem_api_oplog.WrappedFunctionTypeReadLocal:
+
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (18 * 4))) = int8(int32(0))
+
+	case golem_api_oplog.WrappedFunctionTypeWriteLocal:
+
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (18 * 4))) = int8(int32(1))
+
+	case golem_api_oplog.WrappedFunctionTypeReadRemote:
+
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (18 * 4))) = int8(int32(2))
+
+	case golem_api_oplog.WrappedFunctionTypeWriteRemote:
+
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (18 * 4))) = int8(int32(3))
+
+	case golem_api_oplog.WrappedFunctionTypeWriteRemoteBatched:
+		payload := functionType.WriteRemoteBatched()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (18 * 4))) = int8(int32(4))
+
+		switch payload.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 18*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := payload.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 18*4))) = int8(int32(1))
+			*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 18*4))) = int64(payload)
+
+		default:
+			panic("unreachable")
+		}
+
+	case golem_api_oplog.WrappedFunctionTypeWriteRemoteTransaction:
+		payload := functionType.WriteRemoteTransaction()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (18 * 4))) = int8(int32(5))
+
+		switch payload.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 18*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := payload.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 18*4))) = int8(int32(1))
+			*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 18*4))) = int64(payload)
+
+		default:
+			panic("unreachable")
+		}
+
+	default:
+		panic("unreachable")
+	}
+	wasm_import_persist_durable_function_invocation(returnArea)
+
+}
+
+//go:wasmimport golem:durability/durability@1.5.0 read-persisted-durable-function-invocation
+func wasm_import_read_persisted_durable_function_invocation(arg0 uintptr)
+
+func ReadPersistedDurableFunctionInvocation() PersistedDurableFunctionInvocation {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (48 + 10*4), 8))
+	wasm_import_read_persisted_durable_function_invocation(returnArea)
+	value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 1*4))))
+	result172 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 3*4))))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 3*4)))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4))))), index*(56+22*4))
+		var variant160 golem_core_types.SchemaTypeBody
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+		case 0:
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+		case 1:
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyBoolType()
+
+		case 2:
+			var option4 witTypes.Option[golem_core_types.NumericRestrictions]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option4 = witTypes.None[golem_core_types.NumericRestrictions]()
+			case 1:
+				var option witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+				case 0:
+
+					option = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+					case 0:
+
+						variant = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 1:
+
+						variant = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					case 2:
+
+						variant = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option = witTypes.Some[golem_core_types.NumericBound](variant)
+				default:
+					panic("unreachable")
+				}
+				var option1 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+				case 0:
+
+					option1 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant0 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+					case 0:
+
+						variant0 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+					case 1:
+
+						variant0 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					case 2:
+
+						variant0 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option1 = witTypes.Some[golem_core_types.NumericBound](variant0)
+				default:
+					panic("unreachable")
+				}
+				var option3 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+				case 0:
+
+					option3 = witTypes.None[string]()
+				case 1:
+					value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+					option3 = witTypes.Some[string](value2)
+				default:
+					panic("unreachable")
+				}
+
+				option4 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option, option1, option3})
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyS8Type(option4)
+
+		case 3:
+			var option11 witTypes.Option[golem_core_types.NumericRestrictions]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option11 = witTypes.None[golem_core_types.NumericRestrictions]()
+			case 1:
+				var option6 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+				case 0:
+
+					option6 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant5 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+					case 0:
+
+						variant5 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 1:
+
+						variant5 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					case 2:
+
+						variant5 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option6 = witTypes.Some[golem_core_types.NumericBound](variant5)
+				default:
+					panic("unreachable")
+				}
+				var option8 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+				case 0:
+
+					option8 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant7 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+					case 0:
+
+						variant7 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+					case 1:
+
+						variant7 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					case 2:
+
+						variant7 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option8 = witTypes.Some[golem_core_types.NumericBound](variant7)
+				default:
+					panic("unreachable")
+				}
+				var option10 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+				case 0:
+
+					option10 = witTypes.None[string]()
+				case 1:
+					value9 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+					option10 = witTypes.Some[string](value9)
+				default:
+					panic("unreachable")
+				}
+
+				option11 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option6, option8, option10})
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyS16Type(option11)
+
+		case 4:
+			var option18 witTypes.Option[golem_core_types.NumericRestrictions]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option18 = witTypes.None[golem_core_types.NumericRestrictions]()
+			case 1:
+				var option13 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+				case 0:
+
+					option13 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant12 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+					case 0:
+
+						variant12 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 1:
+
+						variant12 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					case 2:
+
+						variant12 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option13 = witTypes.Some[golem_core_types.NumericBound](variant12)
+				default:
+					panic("unreachable")
+				}
+				var option15 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+				case 0:
+
+					option15 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant14 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+					case 0:
+
+						variant14 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+					case 1:
+
+						variant14 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					case 2:
+
+						variant14 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option15 = witTypes.Some[golem_core_types.NumericBound](variant14)
+				default:
+					panic("unreachable")
+				}
+				var option17 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+				case 0:
+
+					option17 = witTypes.None[string]()
+				case 1:
+					value16 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+					option17 = witTypes.Some[string](value16)
+				default:
+					panic("unreachable")
+				}
+
+				option18 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option13, option15, option17})
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyS32Type(option18)
+
+		case 5:
+			var option25 witTypes.Option[golem_core_types.NumericRestrictions]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option25 = witTypes.None[golem_core_types.NumericRestrictions]()
+			case 1:
+				var option20 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+				case 0:
+
+					option20 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant19 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+					case 0:
+
+						variant19 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 1:
+
+						variant19 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					case 2:
+
+						variant19 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option20 = witTypes.Some[golem_core_types.NumericBound](variant19)
+				default:
+					panic("unreachable")
+				}
+				var option22 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+				case 0:
+
+					option22 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant21 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+					case 0:
+
+						variant21 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+					case 1:
+
+						variant21 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					case 2:
+
+						variant21 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option22 = witTypes.Some[golem_core_types.NumericBound](variant21)
+				default:
+					panic("unreachable")
+				}
+				var option24 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+				case 0:
+
+					option24 = witTypes.None[string]()
+				case 1:
+					value23 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+					option24 = witTypes.Some[string](value23)
+				default:
+					panic("unreachable")
+				}
+
+				option25 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option20, option22, option24})
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyS64Type(option25)
+
+		case 6:
+			var option32 witTypes.Option[golem_core_types.NumericRestrictions]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option32 = witTypes.None[golem_core_types.NumericRestrictions]()
+			case 1:
+				var option27 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+				case 0:
+
+					option27 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant26 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+					case 0:
+
+						variant26 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 1:
+
+						variant26 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					case 2:
+
+						variant26 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option27 = witTypes.Some[golem_core_types.NumericBound](variant26)
+				default:
+					panic("unreachable")
+				}
+				var option29 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+				case 0:
+
+					option29 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant28 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+					case 0:
+
+						variant28 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+					case 1:
+
+						variant28 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					case 2:
+
+						variant28 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option29 = witTypes.Some[golem_core_types.NumericBound](variant28)
+				default:
+					panic("unreachable")
+				}
+				var option31 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+				case 0:
+
+					option31 = witTypes.None[string]()
+				case 1:
+					value30 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+					option31 = witTypes.Some[string](value30)
+				default:
+					panic("unreachable")
+				}
+
+				option32 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option27, option29, option31})
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyU8Type(option32)
+
+		case 7:
+			var option39 witTypes.Option[golem_core_types.NumericRestrictions]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option39 = witTypes.None[golem_core_types.NumericRestrictions]()
+			case 1:
+				var option34 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+				case 0:
+
+					option34 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant33 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+					case 0:
+
+						variant33 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 1:
+
+						variant33 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					case 2:
+
+						variant33 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option34 = witTypes.Some[golem_core_types.NumericBound](variant33)
+				default:
+					panic("unreachable")
+				}
+				var option36 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+				case 0:
+
+					option36 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant35 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+					case 0:
+
+						variant35 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+					case 1:
+
+						variant35 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					case 2:
+
+						variant35 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option36 = witTypes.Some[golem_core_types.NumericBound](variant35)
+				default:
+					panic("unreachable")
+				}
+				var option38 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+				case 0:
+
+					option38 = witTypes.None[string]()
+				case 1:
+					value37 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+					option38 = witTypes.Some[string](value37)
+				default:
+					panic("unreachable")
+				}
+
+				option39 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option34, option36, option38})
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyU16Type(option39)
+
+		case 8:
+			var option46 witTypes.Option[golem_core_types.NumericRestrictions]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option46 = witTypes.None[golem_core_types.NumericRestrictions]()
+			case 1:
+				var option41 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+				case 0:
+
+					option41 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant40 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+					case 0:
+
+						variant40 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 1:
+
+						variant40 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					case 2:
+
+						variant40 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option41 = witTypes.Some[golem_core_types.NumericBound](variant40)
+				default:
+					panic("unreachable")
+				}
+				var option43 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+				case 0:
+
+					option43 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant42 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+					case 0:
+
+						variant42 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+					case 1:
+
+						variant42 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					case 2:
+
+						variant42 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option43 = witTypes.Some[golem_core_types.NumericBound](variant42)
+				default:
+					panic("unreachable")
+				}
+				var option45 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+				case 0:
+
+					option45 = witTypes.None[string]()
+				case 1:
+					value44 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+					option45 = witTypes.Some[string](value44)
+				default:
+					panic("unreachable")
+				}
+
+				option46 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option41, option43, option45})
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyU32Type(option46)
+
+		case 9:
+			var option53 witTypes.Option[golem_core_types.NumericRestrictions]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option53 = witTypes.None[golem_core_types.NumericRestrictions]()
+			case 1:
+				var option48 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+				case 0:
+
+					option48 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant47 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+					case 0:
+
+						variant47 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 1:
+
+						variant47 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					case 2:
+
+						variant47 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option48 = witTypes.Some[golem_core_types.NumericBound](variant47)
+				default:
+					panic("unreachable")
+				}
+				var option50 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+				case 0:
+
+					option50 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant49 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+					case 0:
+
+						variant49 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+					case 1:
+
+						variant49 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					case 2:
+
+						variant49 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option50 = witTypes.Some[golem_core_types.NumericBound](variant49)
+				default:
+					panic("unreachable")
+				}
+				var option52 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+				case 0:
+
+					option52 = witTypes.None[string]()
+				case 1:
+					value51 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+					option52 = witTypes.Some[string](value51)
+				default:
+					panic("unreachable")
+				}
+
+				option53 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option48, option50, option52})
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyU64Type(option53)
+
+		case 10:
+			var option60 witTypes.Option[golem_core_types.NumericRestrictions]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option60 = witTypes.None[golem_core_types.NumericRestrictions]()
+			case 1:
+				var option55 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+				case 0:
+
+					option55 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant54 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+					case 0:
+
+						variant54 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 1:
+
+						variant54 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					case 2:
+
+						variant54 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option55 = witTypes.Some[golem_core_types.NumericBound](variant54)
+				default:
+					panic("unreachable")
+				}
+				var option57 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+				case 0:
+
+					option57 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant56 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+					case 0:
+
+						variant56 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+					case 1:
+
+						variant56 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					case 2:
+
+						variant56 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option57 = witTypes.Some[golem_core_types.NumericBound](variant56)
+				default:
+					panic("unreachable")
+				}
+				var option59 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+				case 0:
+
+					option59 = witTypes.None[string]()
+				case 1:
+					value58 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+					option59 = witTypes.Some[string](value58)
+				default:
+					panic("unreachable")
+				}
+
+				option60 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option55, option57, option59})
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyF32Type(option60)
+
+		case 11:
+			var option67 witTypes.Option[golem_core_types.NumericRestrictions]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option67 = witTypes.None[golem_core_types.NumericRestrictions]()
+			case 1:
+				var option62 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+				case 0:
+
+					option62 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant61 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+					case 0:
+
+						variant61 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 1:
+
+						variant61 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					case 2:
+
+						variant61 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option62 = witTypes.Some[golem_core_types.NumericBound](variant61)
+				default:
+					panic("unreachable")
+				}
+				var option64 witTypes.Option[golem_core_types.NumericBound]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) {
+				case 0:
+
+					option64 = witTypes.None[golem_core_types.NumericBound]()
+				case 1:
+					var variant63 golem_core_types.NumericBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) {
+					case 0:
+
+						variant63 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))
+
+					case 1:
+
+						variant63 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					case 2:
+
+						variant63 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))))
+
+					default:
+						panic("unreachable")
+					}
+
+					option64 = witTypes.Some[golem_core_types.NumericBound](variant63)
+				default:
+					panic("unreachable")
+				}
+				var option66 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) {
+				case 0:
+
+					option66 = witTypes.None[string]()
+				case 1:
+					value65 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))
+
+					option66 = witTypes.Some[string](value65)
+				default:
+					panic("unreachable")
+				}
+
+				option67 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option62, option64, option66})
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyF64Type(option67)
+
+		case 12:
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyCharType()
+
+		case 13:
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyStringType()
+
+		case 14:
+			result79 := make([]golem_core_types.NamedFieldType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(17*4))
+				value68 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+				var option70 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+				case 0:
+
+					option70 = witTypes.None[string]()
+				case 1:
+					value69 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+					option70 = witTypes.Some[string](value69)
+				default:
+					panic("unreachable")
+				}
+				result := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))))), index*(2*4))
+					value71 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result = append(result, value71)
+				}
+
+				result73 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))), index*(2*4))
+					value72 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result73 = append(result73, value72)
+				}
+
+				var option75 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) {
+				case 0:
+
+					option75 = witTypes.None[string]()
+				case 1:
+					value74 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))
+
+					option75 = witTypes.Some[string](value74)
+				default:
+					panic("unreachable")
+				}
+				var option78 witTypes.Option[golem_core_types.Role]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) {
+				case 0:
+
+					option78 = witTypes.None[golem_core_types.Role]()
+				case 1:
+					var variant77 golem_core_types.Role
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) {
+					case 0:
+
+						variant77 = golem_core_types.MakeRoleMultimodal()
+
+					case 1:
+
+						variant77 = golem_core_types.MakeRoleUnstructuredText()
+
+					case 2:
+
+						variant77 = golem_core_types.MakeRoleUnstructuredBinary()
+
+					case 3:
+						value76 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))))
+
+						variant77 = golem_core_types.MakeRoleOther(value76)
+
+					default:
+						panic("unreachable")
+					}
+
+					option78 = witTypes.Some[golem_core_types.Role](variant77)
+				default:
+					panic("unreachable")
+				}
+
+				result79 = append(result79, golem_core_types.NamedFieldType{value68, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option70, result, result73, option75, option78}})
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyRecordType(result79)
+
+		case 15:
+			result93 := make([]golem_core_types.VariantCaseType, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(8+16*4))
+				value80 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+				var option81 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+				case 0:
+
+					option81 = witTypes.None[int32]()
+				case 1:
+
+					option81 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))))
+				default:
+					panic("unreachable")
+				}
+				var option83 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+
+					option83 = witTypes.None[string]()
+				case 1:
+					value82 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+					option83 = witTypes.Some[string](value82)
+				default:
+					panic("unreachable")
+				}
+				result85 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+					value84 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result85 = append(result85, value84)
+				}
+
+				result87 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))))), index*(2*4))
+					value86 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result87 = append(result87, value86)
+				}
+
+				var option89 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) {
+				case 0:
+
+					option89 = witTypes.None[string]()
+				case 1:
+					value88 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))))
+
+					option89 = witTypes.Some[string](value88)
+				default:
+					panic("unreachable")
+				}
+				var option92 witTypes.Option[golem_core_types.Role]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) {
+				case 0:
+
+					option92 = witTypes.None[golem_core_types.Role]()
+				case 1:
+					var variant91 golem_core_types.Role
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) {
+					case 0:
+
+						variant91 = golem_core_types.MakeRoleMultimodal()
+
+					case 1:
+
+						variant91 = golem_core_types.MakeRoleUnstructuredText()
+
+					case 2:
+
+						variant91 = golem_core_types.MakeRoleUnstructuredBinary()
+
+					case 3:
+						value90 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))))
+
+						variant91 = golem_core_types.MakeRoleOther(value90)
+
+					default:
+						panic("unreachable")
+					}
+
+					option92 = witTypes.Some[golem_core_types.Role](variant91)
+				default:
+					panic("unreachable")
+				}
+
+				result93 = append(result93, golem_core_types.VariantCaseType{value80, option81, golem_core_types.MetadataEnvelope{option83, result85, result87, option89, option92}})
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyVariantType(result93)
+
+		case 16:
+			result95 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+				value94 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+				result95 = append(result95, value94)
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyEnumType(result95)
+
+		case 17:
+			result97 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(2*4))
+				value96 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+				result97 = append(result97, value96)
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyFlagsType(result97)
+
+		case 18:
+			result98 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+				result98 = append(result98, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyTupleType(result98)
+
+		case 19:
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+		case 20:
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyFixedListType(golem_core_types.FixedListSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+		case 21:
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))})
+
+		case 22:
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+		case 23:
+			var option99 witTypes.Option[int32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option99 = witTypes.None[int32]()
+			case 1:
+
+				option99 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+			default:
+				panic("unreachable")
+			}
+			var option100 witTypes.Option[int32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+			case 0:
+
+				option100 = witTypes.None[int32]()
+			case 1:
+
+				option100 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option99, option100})
+
+		case 24:
+			var option103 witTypes.Option[[]string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option103 = witTypes.None[[]string]()
+			case 1:
+				result102 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+					value101 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result102 = append(result102, value101)
+				}
+
+				option103 = witTypes.Some[[]string](result102)
+			default:
+				panic("unreachable")
+			}
+			var option104 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+			case 0:
+
+				option104 = witTypes.None[uint32]()
+			case 1:
+
+				option104 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+			default:
+				panic("unreachable")
+			}
+			var option105 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+			case 0:
+
+				option105 = witTypes.None[uint32]()
+			case 1:
+
+				option105 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+			default:
+				panic("unreachable")
+			}
+			var option107 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) {
+			case 0:
+
+				option107 = witTypes.None[string]()
+			case 1:
+				value106 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))))
+
+				option107 = witTypes.Some[string](value106)
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option103, option104, option105, option107})
+
+		case 25:
+			var option110 witTypes.Option[[]string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option110 = witTypes.None[[]string]()
+			case 1:
+				result109 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+					value108 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result109 = append(result109, value108)
+				}
+
+				option110 = witTypes.Some[[]string](result109)
+			default:
+				panic("unreachable")
+			}
+			var option111 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+			case 0:
+
+				option111 = witTypes.None[uint32]()
+			case 1:
+
+				option111 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4)))))
+			default:
+				panic("unreachable")
+			}
+			var option112 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) {
+			case 0:
+
+				option112 = witTypes.None[uint32]()
+			case 1:
+
+				option112 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4)))))
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option110, option111, option112})
+
+		case 26:
+			var option115 witTypes.Option[[]string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+			case 0:
+
+				option115 = witTypes.None[[]string]()
+			case 1:
+				result114 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+					value113 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result114 = append(result114, value113)
+				}
+
+				option115 = witTypes.Some[[]string](result114)
+			default:
+				panic("unreachable")
+			}
+			var option118 witTypes.Option[[]string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+			case 0:
+
+				option118 = witTypes.None[[]string]()
+			case 1:
+				result117 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(2*4))
+					value116 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result117 = append(result117, value116)
+				}
+
+				option118 = witTypes.Some[[]string](result117)
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyPathType(golem_core_types.PathSpec{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), option115, option118})
+
+		case 27:
+			var option121 witTypes.Option[[]string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option121 = witTypes.None[[]string]()
+			case 1:
+				result120 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))), index*(2*4))
+					value119 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result120 = append(result120, value119)
+				}
+
+				option121 = witTypes.Some[[]string](result120)
+			default:
+				panic("unreachable")
+			}
+			var option124 witTypes.Option[[]string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+			case 0:
+
+				option124 = witTypes.None[[]string]()
+			case 1:
+				result123 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))), index*(2*4))
+					value122 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result123 = append(result123, value122)
+				}
+
+				option124 = witTypes.Some[[]string](result123)
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option121, option124})
+
+		case 28:
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyDatetimeType()
+
+		case 29:
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyDurationType()
+
+		case 30:
+			value125 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			result127 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*(2*4))
+				value126 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+				result127 = append(result127, value126)
+			}
+
+			var option129 witTypes.Option[golem_core_types.QuantityValue]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) {
+			case 0:
+
+				option129 = witTypes.None[golem_core_types.QuantityValue]()
+			case 1:
+				value128 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))))
+
+				option129 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))), value128})
+			default:
+				panic("unreachable")
+			}
+			var option131 witTypes.Option[golem_core_types.QuantityValue]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) {
+			case 0:
+
+				option131 = witTypes.None[golem_core_types.QuantityValue]()
+			case 1:
+				value130 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))))
+
+				option131 = witTypes.Some[golem_core_types.QuantityValue](golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))), value130})
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value125, result127, option129, option131})
+
+		case 31:
+			result153 := make([]golem_core_types.UnionBranch, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*(23*4))
+				value132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+				var variant141 golem_core_types.DiscriminatorRule
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) {
+				case 0:
+					value133 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+					variant141 = golem_core_types.MakeDiscriminatorRulePrefix(value133)
+
+				case 1:
+					value134 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+					variant141 = golem_core_types.MakeDiscriminatorRuleSuffix(value134)
+
+				case 2:
+					value135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+					variant141 = golem_core_types.MakeDiscriminatorRuleContains(value135)
+
+				case 3:
+					value136 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+					variant141 = golem_core_types.MakeDiscriminatorRuleRegex(value136)
+
+				case 4:
+					value137 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+					var option139 witTypes.Option[string]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) {
+					case 0:
+
+						option139 = witTypes.None[string]()
+					case 1:
+						value138 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))))
+
+						option139 = witTypes.Some[string](value138)
+					default:
+						panic("unreachable")
+					}
+
+					variant141 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value137, option139})
+
+				case 5:
+					value140 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))))
+
+					variant141 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value140)
+
+				default:
+					panic("unreachable")
+				}
+				var option143 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) {
+				case 0:
+
+					option143 = witTypes.None[string]()
+				case 1:
+					value142 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))))
+
+					option143 = witTypes.Some[string](value142)
+				default:
+					panic("unreachable")
+				}
+				result145 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))))), index*(2*4))
+					value144 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result145 = append(result145, value144)
+				}
+
+				result147 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))))), index*(2*4))
+					value146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result147 = append(result147, value146)
+				}
+
+				var option149 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) {
+				case 0:
+
+					option149 = witTypes.None[string]()
+				case 1:
+					value148 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))))
+
+					option149 = witTypes.Some[string](value148)
+				default:
+					panic("unreachable")
+				}
+				var option152 witTypes.Option[golem_core_types.Role]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) {
+				case 0:
+
+					option152 = witTypes.None[golem_core_types.Role]()
+				case 1:
+					var variant151 golem_core_types.Role
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) {
+					case 0:
+
+						variant151 = golem_core_types.MakeRoleMultimodal()
+
+					case 1:
+
+						variant151 = golem_core_types.MakeRoleUnstructuredText()
+
+					case 2:
+
+						variant151 = golem_core_types.MakeRoleUnstructuredBinary()
+
+					case 3:
+						value150 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))))
+
+						variant151 = golem_core_types.MakeRoleOther(value150)
+
+					default:
+						panic("unreachable")
+					}
+
+					option152 = witTypes.Some[golem_core_types.Role](variant151)
+				default:
+					panic("unreachable")
+				}
+
+				result153 = append(result153, golem_core_types.UnionBranch{value132, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant141, golem_core_types.MetadataEnvelope{option143, result145, result147, option149, option152}})
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result153})
+
+		case 32:
+			var option155 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) {
+			case 0:
+
+				option155 = witTypes.None[string]()
+			case 1:
+				value154 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+				option155 = witTypes.Some[string](value154)
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option155})
+
+		case 33:
+			var option157 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option157 = witTypes.None[string]()
+			case 1:
+				value156 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+				option157 = witTypes.Some[string](value156)
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option157})
+
+		case 34:
+			var option158 witTypes.Option[int32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option158 = witTypes.None[int32]()
+			case 1:
+
+				option158 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyFutureType(option158)
+
+		case 35:
+			var option159 witTypes.Option[int32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option159 = witTypes.None[int32]()
+			case 1:
+
+				option159 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+			default:
+				panic("unreachable")
+			}
+
+			variant160 = golem_core_types.MakeSchemaTypeBodyStreamType(option159)
+
+		default:
+			panic("unreachable")
+		}
+		var option162 witTypes.Option[string]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) {
+		case 0:
+
+			option162 = witTypes.None[string]()
+		case 1:
+			value161 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))))
+
+			option162 = witTypes.Some[string](value161)
+		default:
+			panic("unreachable")
+		}
+		result164 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))))), index*(2*4))
+			value163 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+			result164 = append(result164, value163)
+		}
+
+		result166 := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))))), index*(2*4))
+			value165 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+			result166 = append(result166, value165)
+		}
+
+		var option168 witTypes.Option[string]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) {
+		case 0:
+
+			option168 = witTypes.None[string]()
+		case 1:
+			value167 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))))
+
+			option168 = witTypes.Some[string](value167)
+		default:
+			panic("unreachable")
+		}
+		var option171 witTypes.Option[golem_core_types.Role]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) {
+		case 0:
+
+			option171 = witTypes.None[golem_core_types.Role]()
+		case 1:
+			var variant170 golem_core_types.Role
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) {
+			case 0:
+
+				variant170 = golem_core_types.MakeRoleMultimodal()
+
+			case 1:
+
+				variant170 = golem_core_types.MakeRoleUnstructuredText()
+
+			case 2:
+
+				variant170 = golem_core_types.MakeRoleUnstructuredBinary()
+
+			case 3:
+				value169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))))
+
+				variant170 = golem_core_types.MakeRoleOther(value169)
+
+			default:
+				panic("unreachable")
+			}
+
+			option171 = witTypes.Some[golem_core_types.Role](variant170)
+		default:
+			panic("unreachable")
+		}
+
+		result172 = append(result172, golem_core_types.SchemaTypeNode{variant160, golem_core_types.MetadataEnvelope{option162, result164, result166, option168, option171}})
+	}
+
+	result176 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 5*4))))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 5*4)))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 4*4))))), index*(6*4))
+		value173 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+		var option175 witTypes.Option[string]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) {
+		case 0:
+
+			option175 = witTypes.None[string]()
+		case 1:
+			value174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))))
+
+			option175 = witTypes.Some[string](value174)
+		default:
+			panic("unreachable")
+		}
+
+		result176 = append(result176, golem_core_types.SchemaTypeDef{value173, option175, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))})
+	}
+
+	result200 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 8*4))))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 8*4)))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 7*4))))), index*(16+4*4))
+		var variant199 golem_core_types.SchemaValueNode
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+		case 0:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+		case 1:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+		case 2:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+		case 3:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+		case 4:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+		case 5:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+		case 6:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+		case 7:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+		case 8:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+		case 9:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+		case 10:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+		case 11:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+		case 12:
+			value177 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+			variant199 = golem_core_types.MakeSchemaValueNodeStringValue(value177)
+
+		case 13:
+			result178 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+				result178 = append(result178, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+			}
+
+			variant199 = golem_core_types.MakeSchemaValueNodeRecordValue(result178)
+
+		case 14:
+			var option179 witTypes.Option[int32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+			case 0:
+
+				option179 = witTypes.None[int32]()
+			case 1:
+
+				option179 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+			default:
+				panic("unreachable")
+			}
+
+			variant199 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option179})
+
+		case 15:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+		case 16:
+			result180 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+				result180 = append(result180, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+			}
+
+			variant199 = golem_core_types.MakeSchemaValueNodeFlagsValue(result180)
+
+		case 17:
+			result181 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+				result181 = append(result181, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+			}
+
+			variant199 = golem_core_types.MakeSchemaValueNodeTupleValue(result181)
+
+		case 18:
+			result182 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+				result182 = append(result182, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+			}
+
+			variant199 = golem_core_types.MakeSchemaValueNodeListValue(result182)
+
+		case 19:
+			result183 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+				result183 = append(result183, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+			}
+
+			variant199 = golem_core_types.MakeSchemaValueNodeFixedListValue(result183)
+
+		case 20:
+			result184 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+				result184 = append(result184, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+			}
+
+			variant199 = golem_core_types.MakeSchemaValueNodeMapValue(result184)
+
+		case 21:
+			var option185 witTypes.Option[int32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+
+				option185 = witTypes.None[int32]()
+			case 1:
+
+				option185 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+			default:
+				panic("unreachable")
+			}
+
+			variant199 = golem_core_types.MakeSchemaValueNodeOptionValue(option185)
+
+		case 22:
+			var variant188 golem_core_types.ResultValuePayload
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+			case 0:
+				var option186 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+				case 0:
+
+					option186 = witTypes.None[int32]()
+				case 1:
+
+					option186 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+				default:
+					panic("unreachable")
+				}
+
+				variant188 = golem_core_types.MakeResultValuePayloadOkValue(option186)
+
+			case 1:
+				var option187 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+				case 0:
+
+					option187 = witTypes.None[int32]()
+				case 1:
+
+					option187 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+				default:
+					panic("unreachable")
+				}
+
+				variant188 = golem_core_types.MakeResultValuePayloadErrValue(option187)
+
+			default:
+				panic("unreachable")
+			}
+
+			variant199 = golem_core_types.MakeSchemaValueNodeResultValue(variant188)
+
+		case 23:
+			value189 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			var option191 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+			case 0:
+
+				option191 = witTypes.None[string]()
+			case 1:
+				value190 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+				option191 = witTypes.Some[string](value190)
+			default:
+				panic("unreachable")
+			}
+
+			variant199 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value189, option191})
+
+		case 24:
+			value192 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			var option194 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+			case 0:
+
+				option194 = witTypes.None[string]()
+			case 1:
+				value193 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+				option194 = witTypes.Some[string](value193)
+			default:
+				panic("unreachable")
+			}
+
+			variant199 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value192, option194})
+
+		case 25:
+			value195 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+			variant199 = golem_core_types.MakeSchemaValueNodePathValue(value195)
+
+		case 26:
+			value196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+			variant199 = golem_core_types.MakeSchemaValueNodeUrlValue(value196)
+
+		case 27:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+		case 28:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+		case 29:
+			value197 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+			variant199 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value197})
+
+		case 30:
+			value198 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+			variant199 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value198, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+		case 31:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+		case 32:
+
+			variant199 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+		default:
+			panic("unreachable")
+		}
+
+		result200 = append(result200, variant199)
+	}
+
+	var variant203 golem_api_oplog.WrappedFunctionType
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 10*4)))) {
+	case 0:
+
+		variant203 = golem_api_oplog.MakeWrappedFunctionTypeReadLocal()
+
+	case 1:
+
+		variant203 = golem_api_oplog.MakeWrappedFunctionTypeWriteLocal()
+
+	case 2:
+
+		variant203 = golem_api_oplog.MakeWrappedFunctionTypeReadRemote()
+
+	case 3:
+
+		variant203 = golem_api_oplog.MakeWrappedFunctionTypeWriteRemote()
+
+	case 4:
+		var option201 witTypes.Option[uint64]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 10*4)))) {
+		case 0:
+
+			option201 = witTypes.None[uint64]()
+		case 1:
+
+			option201 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (32 + 10*4)))))
+		default:
+			panic("unreachable")
+		}
+
+		variant203 = golem_api_oplog.MakeWrappedFunctionTypeWriteRemoteBatched(option201)
+
+	case 5:
+		var option202 witTypes.Option[uint64]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 10*4)))) {
+		case 0:
+
+			option202 = witTypes.None[uint64]()
+		case 1:
+
+			option202 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (32 + 10*4)))))
+		default:
+			panic("unreachable")
+		}
+
+		variant203 = golem_api_oplog.MakeWrappedFunctionTypeWriteRemoteTransaction(option202)
+
+	default:
+		panic("unreachable")
+	}
+	result204 := PersistedDurableFunctionInvocation{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 0)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))}, value, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result172, result176, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 6*4)))}, golem_core_types.SchemaValueTree{result200, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 9*4)))}}, variant203, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (40 + 10*4)))))}
+	return result204
+
+}
diff --git a/sdks/go/golem/internal/wit/golem_quota_types/empty.s b/sdks/go/golem/internal/wit/golem_quota_types/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_quota_types/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_quota_types/wit_bindings.go b/sdks/go/golem/internal/wit/golem_quota_types/wit_bindings.go
new file mode 100644
index 0000000000..0a8d2c4210
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_quota_types/wit_bindings.go
@@ -0,0 +1,176 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_quota_types
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type QuotaToken = golem_core_types.QuotaToken
+
+// Error returned when a reservation cannot be satisfied because the
+// resource's enforcement policy is `reject`.
+//
+// The inner value is an optional estimate in nanoseconds of how long
+// the caller would need to wait for capacity (only available for
+// rate-limited resources).
+type FailedReservation struct {
+	EstimatedWaitNanos witTypes.Option[uint64]
+}
+
+//go:wasmimport golem:quota/types@1.5.0 [resource-drop]reservation
+func resourceDropReservation(handle int32)
+
+// A short-lived capability that represents a pending or committed
+// resource consumption.  Drop without committing is equivalent to
+// committing zero usage.
+type Reservation struct {
+	handle *witRuntime.Handle
+}
+
+func (self *Reservation) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *Reservation) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *Reservation) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *Reservation) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropReservation(handle)
+	}
+}
+
+func ReservationFromOwnHandle(handleValue int32) *Reservation {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &Reservation{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropReservation(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func ReservationFromBorrowHandle(handleValue int32) *Reservation {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &Reservation{handle}
+}
+
+//go:wasmimport golem:quota/types@1.5.0 [static]reservation.commit
+func wasm_import_static_reservation_commit(arg0 int32, arg1 int64)
+
+func ReservationCommit(this *Reservation, used uint64) {
+
+	wasm_import_static_reservation_commit((this).TakeHandle(), int64(used))
+
+}
+
+//go:wasmimport golem:quota/types@1.5.0 new-token
+func wasm_import_new_token(arg0 uintptr, arg1 uint32, arg2 int64) int32
+
+func NewToken(resourceName string, expectedUse uint64) *golem_core_types.QuotaToken {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData(resourceName))
+	pinner.Pin(utf8)
+	result := wasm_import_new_token(uintptr(utf8), uint32(len(resourceName)), int64(expectedUse))
+	return golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(result)))
+
+}
+
+//go:wasmimport golem:quota/types@1.5.0 reserve
+func wasm_import_reserve(arg0 int32, arg1 int64, arg2 uintptr)
+
+func Reserve(token *golem_core_types.QuotaToken, amount uint64) witTypes.Result[*Reservation, FailedReservation] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 24, 8))
+	wasm_import_reserve((token).Handle(), int64(amount), returnArea)
+	var result witTypes.Result[*Reservation, FailedReservation]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[*Reservation, FailedReservation](ReservationFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))))
+	case 1:
+		var option witTypes.Option[uint64]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+
+			option = witTypes.None[uint64]()
+		case 1:
+
+			option = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16))))
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[*Reservation, FailedReservation](FailedReservation{option})
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport golem:quota/types@1.5.0 split
+func wasm_import_split(arg0 int32, arg1 int64) int32
+
+func Split(token *golem_core_types.QuotaToken, childExpectedUse uint64) *golem_core_types.QuotaToken {
+
+	result := wasm_import_split((token).Handle(), int64(childExpectedUse))
+	return golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(result)))
+
+}
+
+//go:wasmimport golem:quota/types@1.5.0 merge
+func wasm_import_merge(arg0 int32, arg1 int32)
+
+func Merge(token *golem_core_types.QuotaToken, other *golem_core_types.QuotaToken) {
+
+	wasm_import_merge((token).Handle(), (other).TakeHandle())
+
+}
diff --git a/sdks/go/golem/internal/wit/golem_rdbms_ignite2/empty.s b/sdks/go/golem/internal/wit/golem_rdbms_ignite2/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_rdbms_ignite2/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_rdbms_ignite2/wit_bindings.go b/sdks/go/golem/internal/wit/golem_rdbms_ignite2/wit_bindings.go
new file mode 100644
index 0000000000..8b85c26bc2
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_rdbms_ignite2/wit_bindings.go
@@ -0,0 +1,2036 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_rdbms_ignite2
+
+import (
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+const (
+	ErrorConnectionFailure     uint8 = 0
+	ErrorQueryParameterFailure uint8 = 1
+	ErrorQueryExecutionFailure uint8 = 2
+	ErrorQueryResponseFailure  uint8 = 3
+	ErrorOther                 uint8 = 4
+)
+
+// ── Error ──────────────────────────────────────────────────────────────────
+type Error struct {
+	tag   uint8
+	value any
+}
+
+func (self Error) Tag() uint8 {
+	return self.tag
+}
+
+func (self Error) ConnectionFailure() string {
+	if self.tag != ErrorConnectionFailure {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) QueryParameterFailure() string {
+	if self.tag != ErrorQueryParameterFailure {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) QueryExecutionFailure() string {
+	if self.tag != ErrorQueryExecutionFailure {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) QueryResponseFailure() string {
+	if self.tag != ErrorQueryResponseFailure {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) Other() string {
+	if self.tag != ErrorOther {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+
+func MakeErrorConnectionFailure(value string) Error {
+	return Error{ErrorConnectionFailure, value}
+}
+func MakeErrorQueryParameterFailure(value string) Error {
+	return Error{ErrorQueryParameterFailure, value}
+}
+func MakeErrorQueryExecutionFailure(value string) Error {
+	return Error{ErrorQueryExecutionFailure, value}
+}
+func MakeErrorQueryResponseFailure(value string) Error {
+	return Error{ErrorQueryResponseFailure, value}
+}
+func MakeErrorOther(value string) Error {
+	return Error{ErrorOther, value}
+}
+
+const (
+	DbValueDbNull    uint8 = 0
+	DbValueDbBoolean uint8 = 1
+	DbValueDbByte    uint8 = 2
+	DbValueDbShort   uint8 = 3
+	DbValueDbInt     uint8 = 4
+	DbValueDbLong    uint8 = 5
+	DbValueDbFloat   uint8 = 6
+	DbValueDbDouble  uint8 = 7
+	// 16-bit Unicode code unit (Java char).
+	DbValueDbChar   uint8 = 8
+	DbValueDbString uint8 = 9
+	DbValueDbUuid   uint8 = 10
+	// Milliseconds since Unix epoch (UTC).
+	DbValueDbDate uint8 = 11
+	// (milliseconds since epoch, sub-millisecond nanoseconds 0..999_999).
+	DbValueDbTimestamp uint8 = 12
+	// Nanoseconds since midnight.
+	DbValueDbTime      uint8 = 13
+	DbValueDbDecimal   uint8 = 14
+	DbValueDbByteArray uint8 = 15
+)
+
+// ── Value types (maps 1-to-1 onto ignite_client::IgniteValue) ─────────────
+type DbValue struct {
+	tag   uint8
+	value any
+}
+
+func (self DbValue) Tag() uint8 {
+	return self.tag
+}
+
+func (self DbValue) DbBoolean() bool {
+	if self.tag != DbValueDbBoolean {
+		panic("tag mismatch")
+	}
+	return self.value.(bool)
+}
+func (self DbValue) DbByte() int8 {
+	if self.tag != DbValueDbByte {
+		panic("tag mismatch")
+	}
+	return self.value.(int8)
+}
+func (self DbValue) DbShort() int16 {
+	if self.tag != DbValueDbShort {
+		panic("tag mismatch")
+	}
+	return self.value.(int16)
+}
+func (self DbValue) DbInt() int32 {
+	if self.tag != DbValueDbInt {
+		panic("tag mismatch")
+	}
+	return self.value.(int32)
+}
+func (self DbValue) DbLong() int64 {
+	if self.tag != DbValueDbLong {
+		panic("tag mismatch")
+	}
+	return self.value.(int64)
+}
+func (self DbValue) DbFloat() float32 {
+	if self.tag != DbValueDbFloat {
+		panic("tag mismatch")
+	}
+	return self.value.(float32)
+}
+func (self DbValue) DbDouble() float64 {
+	if self.tag != DbValueDbDouble {
+		panic("tag mismatch")
+	}
+	return self.value.(float64)
+}
+func (self DbValue) DbChar() uint16 {
+	if self.tag != DbValueDbChar {
+		panic("tag mismatch")
+	}
+	return self.value.(uint16)
+}
+func (self DbValue) DbString() string {
+	if self.tag != DbValueDbString {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) DbUuid() witTypes.Tuple2[uint64, uint64] {
+	if self.tag != DbValueDbUuid {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Tuple2[uint64, uint64])
+}
+func (self DbValue) DbDate() int64 {
+	if self.tag != DbValueDbDate {
+		panic("tag mismatch")
+	}
+	return self.value.(int64)
+}
+func (self DbValue) DbTimestamp() witTypes.Tuple2[int64, int32] {
+	if self.tag != DbValueDbTimestamp {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Tuple2[int64, int32])
+}
+func (self DbValue) DbTime() int64 {
+	if self.tag != DbValueDbTime {
+		panic("tag mismatch")
+	}
+	return self.value.(int64)
+}
+func (self DbValue) DbDecimal() string {
+	if self.tag != DbValueDbDecimal {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) DbByteArray() []uint8 {
+	if self.tag != DbValueDbByteArray {
+		panic("tag mismatch")
+	}
+	return self.value.([]uint8)
+}
+
+func MakeDbValueDbNull() DbValue {
+	return DbValue{DbValueDbNull, nil}
+}
+func MakeDbValueDbBoolean(value bool) DbValue {
+	return DbValue{DbValueDbBoolean, value}
+}
+func MakeDbValueDbByte(value int8) DbValue {
+	return DbValue{DbValueDbByte, value}
+}
+func MakeDbValueDbShort(value int16) DbValue {
+	return DbValue{DbValueDbShort, value}
+}
+func MakeDbValueDbInt(value int32) DbValue {
+	return DbValue{DbValueDbInt, value}
+}
+func MakeDbValueDbLong(value int64) DbValue {
+	return DbValue{DbValueDbLong, value}
+}
+func MakeDbValueDbFloat(value float32) DbValue {
+	return DbValue{DbValueDbFloat, value}
+}
+func MakeDbValueDbDouble(value float64) DbValue {
+	return DbValue{DbValueDbDouble, value}
+}
+func MakeDbValueDbChar(value uint16) DbValue {
+	return DbValue{DbValueDbChar, value}
+}
+func MakeDbValueDbString(value string) DbValue {
+	return DbValue{DbValueDbString, value}
+}
+func MakeDbValueDbUuid(value witTypes.Tuple2[uint64, uint64]) DbValue {
+	return DbValue{DbValueDbUuid, value}
+}
+func MakeDbValueDbDate(value int64) DbValue {
+	return DbValue{DbValueDbDate, value}
+}
+func MakeDbValueDbTimestamp(value witTypes.Tuple2[int64, int32]) DbValue {
+	return DbValue{DbValueDbTimestamp, value}
+}
+func MakeDbValueDbTime(value int64) DbValue {
+	return DbValue{DbValueDbTime, value}
+}
+func MakeDbValueDbDecimal(value string) DbValue {
+	return DbValue{DbValueDbDecimal, value}
+}
+func MakeDbValueDbByteArray(value []uint8) DbValue {
+	return DbValue{DbValueDbByteArray, value}
+}
+
+// ── Metadata ───────────────────────────────────────────────────────────────
+type DbColumn struct {
+	Ordinal uint64
+	Name    string
+}
+
+type DbRow struct {
+	Values []DbValue
+}
+
+type DbResult struct {
+	Columns []DbColumn
+	Rows    []DbRow
+}
+
+//go:wasmimport golem:rdbms/ignite2@1.5.0 [resource-drop]db-result-stream
+func resourceDropDbResultStream(handle int32)
+
+// ── Resources ──────────────────────────────────────────────────────────────
+type DbResultStream struct {
+	handle *witRuntime.Handle
+}
+
+func (self *DbResultStream) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *DbResultStream) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *DbResultStream) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *DbResultStream) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropDbResultStream(handle)
+	}
+}
+
+func DbResultStreamFromOwnHandle(handleValue int32) *DbResultStream {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &DbResultStream{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropDbResultStream(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func DbResultStreamFromBorrowHandle(handleValue int32) *DbResultStream {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &DbResultStream{handle}
+}
+
+//go:wasmimport golem:rdbms/ignite2@1.5.0 [resource-drop]db-transaction
+func resourceDropDbTransaction(handle int32)
+
+type DbTransaction struct {
+	handle *witRuntime.Handle
+}
+
+func (self *DbTransaction) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *DbTransaction) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *DbTransaction) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *DbTransaction) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropDbTransaction(handle)
+	}
+}
+
+func DbTransactionFromOwnHandle(handleValue int32) *DbTransaction {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &DbTransaction{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropDbTransaction(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func DbTransactionFromBorrowHandle(handleValue int32) *DbTransaction {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &DbTransaction{handle}
+}
+
+//go:wasmimport golem:rdbms/ignite2@1.5.0 [resource-drop]db-connection
+func resourceDropDbConnection(handle int32)
+
+type DbConnection struct {
+	handle *witRuntime.Handle
+}
+
+func (self *DbConnection) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *DbConnection) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *DbConnection) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *DbConnection) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropDbConnection(handle)
+	}
+}
+
+func DbConnectionFromOwnHandle(handleValue int32) *DbConnection {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &DbConnection{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropDbConnection(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func DbConnectionFromBorrowHandle(handleValue int32) *DbConnection {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &DbConnection{handle}
+}
+
+//go:wasmimport golem:rdbms/ignite2@1.5.0 [method]db-result-stream.get-columns
+func wasm_import_method_db_result_stream_get_columns(arg0 int32, arg1 uintptr)
+
+func (self *DbResultStream) GetColumns() witTypes.Result[[]DbColumn, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	wasm_import_method_db_result_stream_get_columns((self).Handle(), returnArea)
+	var result5 witTypes.Result[[]DbColumn, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		result := make([]DbColumn, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(8+2*4))
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+			result = append(result, DbColumn{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), value})
+		}
+
+		result5 = witTypes.Ok[[]DbColumn, Error](result)
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value0)
+
+		case 1:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value1)
+
+		case 2:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value2)
+
+		case 3:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value3)
+
+		case 4:
+			value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value4)
+
+		default:
+			panic("unreachable")
+		}
+
+		result5 = witTypes.Err[[]DbColumn, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result6 := result5
+	return result6
+
+}
+
+//go:wasmimport golem:rdbms/ignite2@1.5.0 [method]db-result-stream.get-next
+func wasm_import_method_db_result_stream_get_next(arg0 int32, arg1 uintptr)
+
+func (self *DbResultStream) GetNext() witTypes.Result[witTypes.Option[[]DbRow], Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	wasm_import_method_db_result_stream_get_next((self).Handle(), returnArea)
+	var result9 witTypes.Result[witTypes.Option[[]DbRow], Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		var option witTypes.Option[[]DbRow]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+
+			option = witTypes.None[[]DbRow]()
+		case 1:
+			result2 := make([]DbRow, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))), index*(2*4))
+				result := make([]DbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*24)
+					var variant DbValue
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+					case 0:
+
+						variant = MakeDbValueDbNull()
+
+					case 1:
+
+						variant = MakeDbValueDbBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+					case 2:
+
+						variant = MakeDbValueDbByte(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 3:
+
+						variant = MakeDbValueDbShort(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 4:
+
+						variant = MakeDbValueDbInt(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 5:
+
+						variant = MakeDbValueDbLong(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 6:
+
+						variant = MakeDbValueDbFloat(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 7:
+
+						variant = MakeDbValueDbDouble(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 8:
+
+						variant = MakeDbValueDbChar(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+					case 9:
+						value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant = MakeDbValueDbString(value)
+
+					case 10:
+
+						variant = MakeDbValueDbUuid(witTypes.Tuple2[uint64, uint64]{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+					case 11:
+
+						variant = MakeDbValueDbDate(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 12:
+
+						variant = MakeDbValueDbTimestamp(witTypes.Tuple2[int64, int32]{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+					case 13:
+
+						variant = MakeDbValueDbTime(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+					case 14:
+						value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant = MakeDbValueDbDecimal(value0)
+
+					case 15:
+						value1 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+						variant = MakeDbValueDbByteArray(value1)
+
+					default:
+						panic("unreachable")
+					}
+
+					result = append(result, variant)
+				}
+
+				result2 = append(result2, DbRow{result})
+			}
+
+			option = witTypes.Some[[]DbRow](result2)
+		default:
+			panic("unreachable")
+		}
+
+		result9 = witTypes.Ok[witTypes.Option[[]DbRow], Error](option)
+	case 1:
+		var variant8 Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant8 = MakeErrorConnectionFailure(value3)
+
+		case 1:
+			value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant8 = MakeErrorQueryParameterFailure(value4)
+
+		case 2:
+			value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant8 = MakeErrorQueryExecutionFailure(value5)
+
+		case 3:
+			value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant8 = MakeErrorQueryResponseFailure(value6)
+
+		case 4:
+			value7 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant8 = MakeErrorOther(value7)
+
+		default:
+			panic("unreachable")
+		}
+
+		result9 = witTypes.Err[witTypes.Option[[]DbRow], Error](variant8)
+	default:
+		panic("unreachable")
+	}
+	result10 := result9
+	return result10
+
+}
+
+//go:wasmimport golem:rdbms/ignite2@1.5.0 [method]db-transaction.query
+func wasm_import_method_db_transaction_query(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbTransaction) Query(statement string, params []DbValue) witTypes.Result[DbResult, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice := params
+	length := uint32(len(slice))
+	result2 := witRuntime.Allocate(pinner, uintptr(length*24), 8)
+	for index, element := range slice {
+		base := unsafe.Add(result2, index*24)
+
+		switch element.Tag() {
+		case DbValueDbNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+
+		case DbValueDbBoolean:
+			payload := element.DbBoolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueDbByte:
+			payload := element.DbByte()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueDbShort:
+			payload := element.DbShort()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueDbInt:
+			payload := element.DbInt()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbLong:
+			payload := element.DbLong()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbFloat:
+			payload := element.DbFloat()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbDouble:
+			payload := element.DbDouble()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbChar:
+			payload := element.DbChar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueDbString:
+			payload := element.DbString()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueDbUuid:
+			payload := element.DbUuid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).F0)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).F1)
+
+		case DbValueDbDate:
+			payload := element.DbDate()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbTimestamp:
+			payload := element.DbTimestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).F1
+
+		case DbValueDbTime:
+			payload := element.DbTime()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbDecimal:
+			payload := element.DbDecimal()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueDbByteArray:
+			payload := element.DbByteArray()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_transaction_query((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result2), length, returnArea)
+	var result15 witTypes.Result[DbResult, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		result3 := make([]DbColumn, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(8+2*4))
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+			result3 = append(result3, DbColumn{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), value})
+		}
+
+		result8 := make([]DbRow, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))), index*(2*4))
+			result7 := make([]DbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*24)
+				var variant DbValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant = MakeDbValueDbNull()
+
+				case 1:
+
+					variant = MakeDbValueDbBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+				case 2:
+
+					variant = MakeDbValueDbByte(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 3:
+
+					variant = MakeDbValueDbShort(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 4:
+
+					variant = MakeDbValueDbInt(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 5:
+
+					variant = MakeDbValueDbLong(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 6:
+
+					variant = MakeDbValueDbFloat(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 7:
+
+					variant = MakeDbValueDbDouble(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 8:
+
+					variant = MakeDbValueDbChar(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 9:
+					value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueDbString(value4)
+
+				case 10:
+
+					variant = MakeDbValueDbUuid(witTypes.Tuple2[uint64, uint64]{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+				case 11:
+
+					variant = MakeDbValueDbDate(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 12:
+
+					variant = MakeDbValueDbTimestamp(witTypes.Tuple2[int64, int32]{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+				case 13:
+
+					variant = MakeDbValueDbTime(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 14:
+					value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueDbDecimal(value5)
+
+				case 15:
+					value6 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueDbByteArray(value6)
+
+				default:
+					panic("unreachable")
+				}
+
+				result7 = append(result7, variant)
+			}
+
+			result8 = append(result8, DbRow{result7})
+		}
+
+		result15 = witTypes.Ok[DbResult, Error](DbResult{result3, result8})
+	case 1:
+		var variant14 Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value9 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant14 = MakeErrorConnectionFailure(value9)
+
+		case 1:
+			value10 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant14 = MakeErrorQueryParameterFailure(value10)
+
+		case 2:
+			value11 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant14 = MakeErrorQueryExecutionFailure(value11)
+
+		case 3:
+			value12 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant14 = MakeErrorQueryResponseFailure(value12)
+
+		case 4:
+			value13 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant14 = MakeErrorOther(value13)
+
+		default:
+			panic("unreachable")
+		}
+
+		result15 = witTypes.Err[DbResult, Error](variant14)
+	default:
+		panic("unreachable")
+	}
+	result16 := result15
+	return result16
+
+}
+
+//go:wasmimport golem:rdbms/ignite2@1.5.0 [method]db-transaction.query-stream
+func wasm_import_method_db_transaction_query_stream(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbTransaction) QueryStream(statement string, params []DbValue) witTypes.Result[*DbResultStream, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice := params
+	length := uint32(len(slice))
+	result2 := witRuntime.Allocate(pinner, uintptr(length*24), 8)
+	for index, element := range slice {
+		base := unsafe.Add(result2, index*24)
+
+		switch element.Tag() {
+		case DbValueDbNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+
+		case DbValueDbBoolean:
+			payload := element.DbBoolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueDbByte:
+			payload := element.DbByte()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueDbShort:
+			payload := element.DbShort()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueDbInt:
+			payload := element.DbInt()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbLong:
+			payload := element.DbLong()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbFloat:
+			payload := element.DbFloat()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbDouble:
+			payload := element.DbDouble()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbChar:
+			payload := element.DbChar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueDbString:
+			payload := element.DbString()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueDbUuid:
+			payload := element.DbUuid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).F0)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).F1)
+
+		case DbValueDbDate:
+			payload := element.DbDate()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbTimestamp:
+			payload := element.DbTimestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).F1
+
+		case DbValueDbTime:
+			payload := element.DbTime()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbDecimal:
+			payload := element.DbDecimal()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueDbByteArray:
+			payload := element.DbByteArray()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_transaction_query_stream((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result2), length, returnArea)
+	var result7 witTypes.Result[*DbResultStream, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result7 = witTypes.Ok[*DbResultStream, Error](DbResultStreamFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value3)
+
+		case 2:
+			value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value4)
+
+		case 3:
+			value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value5)
+
+		case 4:
+			value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value6)
+
+		default:
+			panic("unreachable")
+		}
+
+		result7 = witTypes.Err[*DbResultStream, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result8 := result7
+	return result8
+
+}
+
+//go:wasmimport golem:rdbms/ignite2@1.5.0 [method]db-transaction.execute
+func wasm_import_method_db_transaction_execute(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbTransaction) Execute(statement string, params []DbValue) witTypes.Result[int64, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (16 + 2*4), 8))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice := params
+	length := uint32(len(slice))
+	result2 := witRuntime.Allocate(pinner, uintptr(length*24), 8)
+	for index, element := range slice {
+		base := unsafe.Add(result2, index*24)
+
+		switch element.Tag() {
+		case DbValueDbNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+
+		case DbValueDbBoolean:
+			payload := element.DbBoolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueDbByte:
+			payload := element.DbByte()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueDbShort:
+			payload := element.DbShort()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueDbInt:
+			payload := element.DbInt()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbLong:
+			payload := element.DbLong()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbFloat:
+			payload := element.DbFloat()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbDouble:
+			payload := element.DbDouble()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbChar:
+			payload := element.DbChar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueDbString:
+			payload := element.DbString()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueDbUuid:
+			payload := element.DbUuid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).F0)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).F1)
+
+		case DbValueDbDate:
+			payload := element.DbDate()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbTimestamp:
+			payload := element.DbTimestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).F1
+
+		case DbValueDbTime:
+			payload := element.DbTime()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbDecimal:
+			payload := element.DbDecimal()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueDbByteArray:
+			payload := element.DbByteArray()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_transaction_execute((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result2), length, returnArea)
+	var result7 witTypes.Result[int64, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result7 = witTypes.Ok[int64, Error](*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8)))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryParameterFailure(value3)
+
+		case 2:
+			value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryExecutionFailure(value4)
+
+		case 3:
+			value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryResponseFailure(value5)
+
+		case 4:
+			value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorOther(value6)
+
+		default:
+			panic("unreachable")
+		}
+
+		result7 = witTypes.Err[int64, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result8 := result7
+	return result8
+
+}
+
+//go:wasmimport golem:rdbms/ignite2@1.5.0 [method]db-transaction.commit
+func wasm_import_method_db_transaction_commit(arg0 int32, arg1 uintptr)
+
+func (self *DbTransaction) Commit() witTypes.Result[witTypes.Unit, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	wasm_import_method_db_transaction_commit((self).Handle(), returnArea)
+	var result witTypes.Result[witTypes.Unit, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, Error](witTypes.Unit{})
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value0)
+
+		case 2:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value1)
+
+		case 3:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value2)
+
+		case 4:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value3)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Unit, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result4 := result
+	return result4
+
+}
+
+//go:wasmimport golem:rdbms/ignite2@1.5.0 [method]db-transaction.rollback
+func wasm_import_method_db_transaction_rollback(arg0 int32, arg1 uintptr)
+
+func (self *DbTransaction) Rollback() witTypes.Result[witTypes.Unit, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	wasm_import_method_db_transaction_rollback((self).Handle(), returnArea)
+	var result witTypes.Result[witTypes.Unit, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, Error](witTypes.Unit{})
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value0)
+
+		case 2:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value1)
+
+		case 3:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value2)
+
+		case 4:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value3)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Unit, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result4 := result
+	return result4
+
+}
+
+//go:wasmimport golem:rdbms/ignite2@1.5.0 [static]db-connection.open
+func wasm_import_static_db_connection_open(arg0 uintptr, arg1 uint32, arg2 uintptr)
+
+func DbConnectionOpen(address string) witTypes.Result[*DbConnection, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(address))
+	pinner.Pin(utf8)
+	wasm_import_static_db_connection_open(uintptr(utf8), uint32(len(address)), returnArea)
+	var result witTypes.Result[*DbConnection, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[*DbConnection, Error](DbConnectionFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value0)
+
+		case 2:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value1)
+
+		case 3:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value2)
+
+		case 4:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value3)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[*DbConnection, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result4 := result
+	return result4
+
+}
+
+//go:wasmimport golem:rdbms/ignite2@1.5.0 [method]db-connection.query
+func wasm_import_method_db_connection_query(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbConnection) Query(statement string, params []DbValue) witTypes.Result[DbResult, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice := params
+	length := uint32(len(slice))
+	result2 := witRuntime.Allocate(pinner, uintptr(length*24), 8)
+	for index, element := range slice {
+		base := unsafe.Add(result2, index*24)
+
+		switch element.Tag() {
+		case DbValueDbNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+
+		case DbValueDbBoolean:
+			payload := element.DbBoolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueDbByte:
+			payload := element.DbByte()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueDbShort:
+			payload := element.DbShort()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueDbInt:
+			payload := element.DbInt()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbLong:
+			payload := element.DbLong()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbFloat:
+			payload := element.DbFloat()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbDouble:
+			payload := element.DbDouble()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbChar:
+			payload := element.DbChar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueDbString:
+			payload := element.DbString()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueDbUuid:
+			payload := element.DbUuid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).F0)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).F1)
+
+		case DbValueDbDate:
+			payload := element.DbDate()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbTimestamp:
+			payload := element.DbTimestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).F1
+
+		case DbValueDbTime:
+			payload := element.DbTime()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbDecimal:
+			payload := element.DbDecimal()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueDbByteArray:
+			payload := element.DbByteArray()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_connection_query((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result2), length, returnArea)
+	var result15 witTypes.Result[DbResult, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		result3 := make([]DbColumn, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(8+2*4))
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+			result3 = append(result3, DbColumn{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), value})
+		}
+
+		result8 := make([]DbRow, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))), index*(2*4))
+			result7 := make([]DbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*24)
+				var variant DbValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant = MakeDbValueDbNull()
+
+				case 1:
+
+					variant = MakeDbValueDbBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+				case 2:
+
+					variant = MakeDbValueDbByte(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 3:
+
+					variant = MakeDbValueDbShort(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 4:
+
+					variant = MakeDbValueDbInt(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 5:
+
+					variant = MakeDbValueDbLong(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 6:
+
+					variant = MakeDbValueDbFloat(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 7:
+
+					variant = MakeDbValueDbDouble(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 8:
+
+					variant = MakeDbValueDbChar(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 9:
+					value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueDbString(value4)
+
+				case 10:
+
+					variant = MakeDbValueDbUuid(witTypes.Tuple2[uint64, uint64]{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+				case 11:
+
+					variant = MakeDbValueDbDate(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 12:
+
+					variant = MakeDbValueDbTimestamp(witTypes.Tuple2[int64, int32]{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+				case 13:
+
+					variant = MakeDbValueDbTime(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 14:
+					value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueDbDecimal(value5)
+
+				case 15:
+					value6 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueDbByteArray(value6)
+
+				default:
+					panic("unreachable")
+				}
+
+				result7 = append(result7, variant)
+			}
+
+			result8 = append(result8, DbRow{result7})
+		}
+
+		result15 = witTypes.Ok[DbResult, Error](DbResult{result3, result8})
+	case 1:
+		var variant14 Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value9 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant14 = MakeErrorConnectionFailure(value9)
+
+		case 1:
+			value10 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant14 = MakeErrorQueryParameterFailure(value10)
+
+		case 2:
+			value11 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant14 = MakeErrorQueryExecutionFailure(value11)
+
+		case 3:
+			value12 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant14 = MakeErrorQueryResponseFailure(value12)
+
+		case 4:
+			value13 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant14 = MakeErrorOther(value13)
+
+		default:
+			panic("unreachable")
+		}
+
+		result15 = witTypes.Err[DbResult, Error](variant14)
+	default:
+		panic("unreachable")
+	}
+	result16 := result15
+	return result16
+
+}
+
+//go:wasmimport golem:rdbms/ignite2@1.5.0 [method]db-connection.query-stream
+func wasm_import_method_db_connection_query_stream(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbConnection) QueryStream(statement string, params []DbValue) witTypes.Result[*DbResultStream, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice := params
+	length := uint32(len(slice))
+	result2 := witRuntime.Allocate(pinner, uintptr(length*24), 8)
+	for index, element := range slice {
+		base := unsafe.Add(result2, index*24)
+
+		switch element.Tag() {
+		case DbValueDbNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+
+		case DbValueDbBoolean:
+			payload := element.DbBoolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueDbByte:
+			payload := element.DbByte()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueDbShort:
+			payload := element.DbShort()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueDbInt:
+			payload := element.DbInt()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbLong:
+			payload := element.DbLong()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbFloat:
+			payload := element.DbFloat()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbDouble:
+			payload := element.DbDouble()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbChar:
+			payload := element.DbChar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueDbString:
+			payload := element.DbString()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueDbUuid:
+			payload := element.DbUuid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).F0)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).F1)
+
+		case DbValueDbDate:
+			payload := element.DbDate()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbTimestamp:
+			payload := element.DbTimestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).F1
+
+		case DbValueDbTime:
+			payload := element.DbTime()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbDecimal:
+			payload := element.DbDecimal()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueDbByteArray:
+			payload := element.DbByteArray()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_connection_query_stream((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result2), length, returnArea)
+	var result7 witTypes.Result[*DbResultStream, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result7 = witTypes.Ok[*DbResultStream, Error](DbResultStreamFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value3)
+
+		case 2:
+			value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value4)
+
+		case 3:
+			value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value5)
+
+		case 4:
+			value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value6)
+
+		default:
+			panic("unreachable")
+		}
+
+		result7 = witTypes.Err[*DbResultStream, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result8 := result7
+	return result8
+
+}
+
+//go:wasmimport golem:rdbms/ignite2@1.5.0 [method]db-connection.execute
+func wasm_import_method_db_connection_execute(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbConnection) Execute(statement string, params []DbValue) witTypes.Result[int64, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (16 + 2*4), 8))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice := params
+	length := uint32(len(slice))
+	result2 := witRuntime.Allocate(pinner, uintptr(length*24), 8)
+	for index, element := range slice {
+		base := unsafe.Add(result2, index*24)
+
+		switch element.Tag() {
+		case DbValueDbNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+
+		case DbValueDbBoolean:
+			payload := element.DbBoolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueDbByte:
+			payload := element.DbByte()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueDbShort:
+			payload := element.DbShort()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueDbInt:
+			payload := element.DbInt()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbLong:
+			payload := element.DbLong()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbFloat:
+			payload := element.DbFloat()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbDouble:
+			payload := element.DbDouble()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbChar:
+			payload := element.DbChar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueDbString:
+			payload := element.DbString()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueDbUuid:
+			payload := element.DbUuid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).F0)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).F1)
+
+		case DbValueDbDate:
+			payload := element.DbDate()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbTimestamp:
+			payload := element.DbTimestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).F0
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).F1
+
+		case DbValueDbTime:
+			payload := element.DbTime()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDbDecimal:
+			payload := element.DbDecimal()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueDbByteArray:
+			payload := element.DbByteArray()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_connection_execute((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result2), length, returnArea)
+	var result7 witTypes.Result[int64, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result7 = witTypes.Ok[int64, Error](*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8)))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryParameterFailure(value3)
+
+		case 2:
+			value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryExecutionFailure(value4)
+
+		case 3:
+			value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryResponseFailure(value5)
+
+		case 4:
+			value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorOther(value6)
+
+		default:
+			panic("unreachable")
+		}
+
+		result7 = witTypes.Err[int64, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result8 := result7
+	return result8
+
+}
+
+//go:wasmimport golem:rdbms/ignite2@1.5.0 [method]db-connection.begin-transaction
+func wasm_import_method_db_connection_begin_transaction(arg0 int32, arg1 uintptr)
+
+func (self *DbConnection) BeginTransaction() witTypes.Result[*DbTransaction, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	wasm_import_method_db_connection_begin_transaction((self).Handle(), returnArea)
+	var result witTypes.Result[*DbTransaction, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[*DbTransaction, Error](DbTransactionFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value0)
+
+		case 2:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value1)
+
+		case 3:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value2)
+
+		case 4:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value3)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[*DbTransaction, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result4 := result
+	return result4
+
+}
diff --git a/sdks/go/golem/internal/wit/golem_rdbms_mysql/empty.s b/sdks/go/golem/internal/wit/golem_rdbms_mysql/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_rdbms_mysql/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_rdbms_mysql/wit_bindings.go b/sdks/go/golem/internal/wit/golem_rdbms_mysql/wit_bindings.go
new file mode 100644
index 0000000000..2420672a0d
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_rdbms_mysql/wit_bindings.go
@@ -0,0 +1,4065 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_rdbms_mysql
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_rdbms_types"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type Date = golem_rdbms_types.Date
+type Time = golem_rdbms_types.Time
+type Timestamp = golem_rdbms_types.Timestamp
+
+const (
+	ErrorConnectionFailure     uint8 = 0
+	ErrorQueryParameterFailure uint8 = 1
+	ErrorQueryExecutionFailure uint8 = 2
+	ErrorQueryResponseFailure  uint8 = 3
+	ErrorOther                 uint8 = 4
+)
+
+type Error struct {
+	tag   uint8
+	value any
+}
+
+func (self Error) Tag() uint8 {
+	return self.tag
+}
+
+func (self Error) ConnectionFailure() string {
+	if self.tag != ErrorConnectionFailure {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) QueryParameterFailure() string {
+	if self.tag != ErrorQueryParameterFailure {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) QueryExecutionFailure() string {
+	if self.tag != ErrorQueryExecutionFailure {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) QueryResponseFailure() string {
+	if self.tag != ErrorQueryResponseFailure {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) Other() string {
+	if self.tag != ErrorOther {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+
+func MakeErrorConnectionFailure(value string) Error {
+	return Error{ErrorConnectionFailure, value}
+}
+func MakeErrorQueryParameterFailure(value string) Error {
+	return Error{ErrorQueryParameterFailure, value}
+}
+func MakeErrorQueryExecutionFailure(value string) Error {
+	return Error{ErrorQueryExecutionFailure, value}
+}
+func MakeErrorQueryResponseFailure(value string) Error {
+	return Error{ErrorQueryResponseFailure, value}
+}
+func MakeErrorOther(value string) Error {
+	return Error{ErrorOther, value}
+}
+
+const (
+	DbColumnTypeBoolean           uint8 = 0
+	DbColumnTypeTinyint           uint8 = 1
+	DbColumnTypeSmallint          uint8 = 2
+	DbColumnTypeMediumint         uint8 = 3
+	DbColumnTypeInt               uint8 = 4
+	DbColumnTypeBigint            uint8 = 5
+	DbColumnTypeTinyintUnsigned   uint8 = 6
+	DbColumnTypeSmallintUnsigned  uint8 = 7
+	DbColumnTypeMediumintUnsigned uint8 = 8
+	DbColumnTypeIntUnsigned       uint8 = 9
+	DbColumnTypeBigintUnsigned    uint8 = 10
+	DbColumnTypeFloat             uint8 = 11
+	DbColumnTypeDouble            uint8 = 12
+	DbColumnTypeDecimal           uint8 = 13
+	DbColumnTypeDate              uint8 = 14
+	DbColumnTypeDatetime          uint8 = 15
+	DbColumnTypeTimestamp         uint8 = 16
+	DbColumnTypeTime              uint8 = 17
+	DbColumnTypeYear              uint8 = 18
+	DbColumnTypeFixchar           uint8 = 19
+	DbColumnTypeVarchar           uint8 = 20
+	DbColumnTypeTinytext          uint8 = 21
+	DbColumnTypeText              uint8 = 22
+	DbColumnTypeMediumtext        uint8 = 23
+	DbColumnTypeLongtext          uint8 = 24
+	DbColumnTypeBinary            uint8 = 25
+	DbColumnTypeVarbinary         uint8 = 26
+	DbColumnTypeTinyblob          uint8 = 27
+	DbColumnTypeBlob              uint8 = 28
+	DbColumnTypeMediumblob        uint8 = 29
+	DbColumnTypeLongblob          uint8 = 30
+	DbColumnTypeEnumeration       uint8 = 31
+	DbColumnTypeSet               uint8 = 32
+	DbColumnTypeBit               uint8 = 33
+	DbColumnTypeJson              uint8 = 34
+)
+
+type DbColumnType struct {
+	tag   uint8
+	value any
+}
+
+func (self DbColumnType) Tag() uint8 {
+	return self.tag
+}
+
+func MakeDbColumnTypeBoolean() DbColumnType {
+	return DbColumnType{DbColumnTypeBoolean, nil}
+}
+func MakeDbColumnTypeTinyint() DbColumnType {
+	return DbColumnType{DbColumnTypeTinyint, nil}
+}
+func MakeDbColumnTypeSmallint() DbColumnType {
+	return DbColumnType{DbColumnTypeSmallint, nil}
+}
+func MakeDbColumnTypeMediumint() DbColumnType {
+	return DbColumnType{DbColumnTypeMediumint, nil}
+}
+func MakeDbColumnTypeInt() DbColumnType {
+	return DbColumnType{DbColumnTypeInt, nil}
+}
+func MakeDbColumnTypeBigint() DbColumnType {
+	return DbColumnType{DbColumnTypeBigint, nil}
+}
+func MakeDbColumnTypeTinyintUnsigned() DbColumnType {
+	return DbColumnType{DbColumnTypeTinyintUnsigned, nil}
+}
+func MakeDbColumnTypeSmallintUnsigned() DbColumnType {
+	return DbColumnType{DbColumnTypeSmallintUnsigned, nil}
+}
+func MakeDbColumnTypeMediumintUnsigned() DbColumnType {
+	return DbColumnType{DbColumnTypeMediumintUnsigned, nil}
+}
+func MakeDbColumnTypeIntUnsigned() DbColumnType {
+	return DbColumnType{DbColumnTypeIntUnsigned, nil}
+}
+func MakeDbColumnTypeBigintUnsigned() DbColumnType {
+	return DbColumnType{DbColumnTypeBigintUnsigned, nil}
+}
+func MakeDbColumnTypeFloat() DbColumnType {
+	return DbColumnType{DbColumnTypeFloat, nil}
+}
+func MakeDbColumnTypeDouble() DbColumnType {
+	return DbColumnType{DbColumnTypeDouble, nil}
+}
+func MakeDbColumnTypeDecimal() DbColumnType {
+	return DbColumnType{DbColumnTypeDecimal, nil}
+}
+func MakeDbColumnTypeDate() DbColumnType {
+	return DbColumnType{DbColumnTypeDate, nil}
+}
+func MakeDbColumnTypeDatetime() DbColumnType {
+	return DbColumnType{DbColumnTypeDatetime, nil}
+}
+func MakeDbColumnTypeTimestamp() DbColumnType {
+	return DbColumnType{DbColumnTypeTimestamp, nil}
+}
+func MakeDbColumnTypeTime() DbColumnType {
+	return DbColumnType{DbColumnTypeTime, nil}
+}
+func MakeDbColumnTypeYear() DbColumnType {
+	return DbColumnType{DbColumnTypeYear, nil}
+}
+func MakeDbColumnTypeFixchar() DbColumnType {
+	return DbColumnType{DbColumnTypeFixchar, nil}
+}
+func MakeDbColumnTypeVarchar() DbColumnType {
+	return DbColumnType{DbColumnTypeVarchar, nil}
+}
+func MakeDbColumnTypeTinytext() DbColumnType {
+	return DbColumnType{DbColumnTypeTinytext, nil}
+}
+func MakeDbColumnTypeText() DbColumnType {
+	return DbColumnType{DbColumnTypeText, nil}
+}
+func MakeDbColumnTypeMediumtext() DbColumnType {
+	return DbColumnType{DbColumnTypeMediumtext, nil}
+}
+func MakeDbColumnTypeLongtext() DbColumnType {
+	return DbColumnType{DbColumnTypeLongtext, nil}
+}
+func MakeDbColumnTypeBinary() DbColumnType {
+	return DbColumnType{DbColumnTypeBinary, nil}
+}
+func MakeDbColumnTypeVarbinary() DbColumnType {
+	return DbColumnType{DbColumnTypeVarbinary, nil}
+}
+func MakeDbColumnTypeTinyblob() DbColumnType {
+	return DbColumnType{DbColumnTypeTinyblob, nil}
+}
+func MakeDbColumnTypeBlob() DbColumnType {
+	return DbColumnType{DbColumnTypeBlob, nil}
+}
+func MakeDbColumnTypeMediumblob() DbColumnType {
+	return DbColumnType{DbColumnTypeMediumblob, nil}
+}
+func MakeDbColumnTypeLongblob() DbColumnType {
+	return DbColumnType{DbColumnTypeLongblob, nil}
+}
+func MakeDbColumnTypeEnumeration() DbColumnType {
+	return DbColumnType{DbColumnTypeEnumeration, nil}
+}
+func MakeDbColumnTypeSet() DbColumnType {
+	return DbColumnType{DbColumnTypeSet, nil}
+}
+func MakeDbColumnTypeBit() DbColumnType {
+	return DbColumnType{DbColumnTypeBit, nil}
+}
+func MakeDbColumnTypeJson() DbColumnType {
+	return DbColumnType{DbColumnTypeJson, nil}
+}
+
+type DbColumn struct {
+	Ordinal    uint64
+	Name       string
+	DbType     DbColumnType
+	DbTypeName string
+}
+
+const (
+	DbValueBoolean           uint8 = 0
+	DbValueTinyint           uint8 = 1
+	DbValueSmallint          uint8 = 2
+	DbValueMediumint         uint8 = 3
+	DbValueInt               uint8 = 4
+	DbValueBigint            uint8 = 5
+	DbValueTinyintUnsigned   uint8 = 6
+	DbValueSmallintUnsigned  uint8 = 7
+	DbValueMediumintUnsigned uint8 = 8
+	DbValueIntUnsigned       uint8 = 9
+	DbValueBigintUnsigned    uint8 = 10
+	DbValueFloat             uint8 = 11
+	DbValueDouble            uint8 = 12
+	DbValueDecimal           uint8 = 13
+	DbValueDate              uint8 = 14
+	DbValueDatetime          uint8 = 15
+	DbValueTimestamp         uint8 = 16
+	DbValueTime              uint8 = 17
+	DbValueYear              uint8 = 18
+	DbValueFixchar           uint8 = 19
+	DbValueVarchar           uint8 = 20
+	DbValueTinytext          uint8 = 21
+	DbValueText              uint8 = 22
+	DbValueMediumtext        uint8 = 23
+	DbValueLongtext          uint8 = 24
+	DbValueBinary            uint8 = 25
+	DbValueVarbinary         uint8 = 26
+	DbValueTinyblob          uint8 = 27
+	DbValueBlob              uint8 = 28
+	DbValueMediumblob        uint8 = 29
+	DbValueLongblob          uint8 = 30
+	DbValueEnumeration       uint8 = 31
+	DbValueSet               uint8 = 32
+	DbValueBit               uint8 = 33
+	DbValueJson              uint8 = 34
+	DbValueNull              uint8 = 35
+)
+
+// Value descriptor for a single database value
+type DbValue struct {
+	tag   uint8
+	value any
+}
+
+func (self DbValue) Tag() uint8 {
+	return self.tag
+}
+
+func (self DbValue) Boolean() bool {
+	if self.tag != DbValueBoolean {
+		panic("tag mismatch")
+	}
+	return self.value.(bool)
+}
+func (self DbValue) Tinyint() int8 {
+	if self.tag != DbValueTinyint {
+		panic("tag mismatch")
+	}
+	return self.value.(int8)
+}
+func (self DbValue) Smallint() int16 {
+	if self.tag != DbValueSmallint {
+		panic("tag mismatch")
+	}
+	return self.value.(int16)
+}
+func (self DbValue) Mediumint() int32 {
+	if self.tag != DbValueMediumint {
+		panic("tag mismatch")
+	}
+	return self.value.(int32)
+}
+func (self DbValue) Int() int32 {
+	if self.tag != DbValueInt {
+		panic("tag mismatch")
+	}
+	return self.value.(int32)
+}
+func (self DbValue) Bigint() int64 {
+	if self.tag != DbValueBigint {
+		panic("tag mismatch")
+	}
+	return self.value.(int64)
+}
+func (self DbValue) TinyintUnsigned() uint8 {
+	if self.tag != DbValueTinyintUnsigned {
+		panic("tag mismatch")
+	}
+	return self.value.(uint8)
+}
+func (self DbValue) SmallintUnsigned() uint16 {
+	if self.tag != DbValueSmallintUnsigned {
+		panic("tag mismatch")
+	}
+	return self.value.(uint16)
+}
+func (self DbValue) MediumintUnsigned() uint32 {
+	if self.tag != DbValueMediumintUnsigned {
+		panic("tag mismatch")
+	}
+	return self.value.(uint32)
+}
+func (self DbValue) IntUnsigned() uint32 {
+	if self.tag != DbValueIntUnsigned {
+		panic("tag mismatch")
+	}
+	return self.value.(uint32)
+}
+func (self DbValue) BigintUnsigned() uint64 {
+	if self.tag != DbValueBigintUnsigned {
+		panic("tag mismatch")
+	}
+	return self.value.(uint64)
+}
+func (self DbValue) Float() float32 {
+	if self.tag != DbValueFloat {
+		panic("tag mismatch")
+	}
+	return self.value.(float32)
+}
+func (self DbValue) Double() float64 {
+	if self.tag != DbValueDouble {
+		panic("tag mismatch")
+	}
+	return self.value.(float64)
+}
+func (self DbValue) Decimal() string {
+	if self.tag != DbValueDecimal {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Date() golem_rdbms_types.Date {
+	if self.tag != DbValueDate {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Date)
+}
+func (self DbValue) Datetime() golem_rdbms_types.Timestamp {
+	if self.tag != DbValueDatetime {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Timestamp)
+}
+func (self DbValue) Timestamp() golem_rdbms_types.Timestamp {
+	if self.tag != DbValueTimestamp {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Timestamp)
+}
+func (self DbValue) Time() golem_rdbms_types.Time {
+	if self.tag != DbValueTime {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Time)
+}
+func (self DbValue) Year() uint16 {
+	if self.tag != DbValueYear {
+		panic("tag mismatch")
+	}
+	return self.value.(uint16)
+}
+func (self DbValue) Fixchar() string {
+	if self.tag != DbValueFixchar {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Varchar() string {
+	if self.tag != DbValueVarchar {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Tinytext() string {
+	if self.tag != DbValueTinytext {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Text() string {
+	if self.tag != DbValueText {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Mediumtext() string {
+	if self.tag != DbValueMediumtext {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Longtext() string {
+	if self.tag != DbValueLongtext {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Binary() []uint8 {
+	if self.tag != DbValueBinary {
+		panic("tag mismatch")
+	}
+	return self.value.([]uint8)
+}
+func (self DbValue) Varbinary() []uint8 {
+	if self.tag != DbValueVarbinary {
+		panic("tag mismatch")
+	}
+	return self.value.([]uint8)
+}
+func (self DbValue) Tinyblob() []uint8 {
+	if self.tag != DbValueTinyblob {
+		panic("tag mismatch")
+	}
+	return self.value.([]uint8)
+}
+func (self DbValue) Blob() []uint8 {
+	if self.tag != DbValueBlob {
+		panic("tag mismatch")
+	}
+	return self.value.([]uint8)
+}
+func (self DbValue) Mediumblob() []uint8 {
+	if self.tag != DbValueMediumblob {
+		panic("tag mismatch")
+	}
+	return self.value.([]uint8)
+}
+func (self DbValue) Longblob() []uint8 {
+	if self.tag != DbValueLongblob {
+		panic("tag mismatch")
+	}
+	return self.value.([]uint8)
+}
+func (self DbValue) Enumeration() string {
+	if self.tag != DbValueEnumeration {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Set() string {
+	if self.tag != DbValueSet {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Bit() []bool {
+	if self.tag != DbValueBit {
+		panic("tag mismatch")
+	}
+	return self.value.([]bool)
+}
+func (self DbValue) Json() string {
+	if self.tag != DbValueJson {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+
+func MakeDbValueBoolean(value bool) DbValue {
+	return DbValue{DbValueBoolean, value}
+}
+func MakeDbValueTinyint(value int8) DbValue {
+	return DbValue{DbValueTinyint, value}
+}
+func MakeDbValueSmallint(value int16) DbValue {
+	return DbValue{DbValueSmallint, value}
+}
+func MakeDbValueMediumint(value int32) DbValue {
+	return DbValue{DbValueMediumint, value}
+}
+func MakeDbValueInt(value int32) DbValue {
+	return DbValue{DbValueInt, value}
+}
+func MakeDbValueBigint(value int64) DbValue {
+	return DbValue{DbValueBigint, value}
+}
+func MakeDbValueTinyintUnsigned(value uint8) DbValue {
+	return DbValue{DbValueTinyintUnsigned, value}
+}
+func MakeDbValueSmallintUnsigned(value uint16) DbValue {
+	return DbValue{DbValueSmallintUnsigned, value}
+}
+func MakeDbValueMediumintUnsigned(value uint32) DbValue {
+	return DbValue{DbValueMediumintUnsigned, value}
+}
+func MakeDbValueIntUnsigned(value uint32) DbValue {
+	return DbValue{DbValueIntUnsigned, value}
+}
+func MakeDbValueBigintUnsigned(value uint64) DbValue {
+	return DbValue{DbValueBigintUnsigned, value}
+}
+func MakeDbValueFloat(value float32) DbValue {
+	return DbValue{DbValueFloat, value}
+}
+func MakeDbValueDouble(value float64) DbValue {
+	return DbValue{DbValueDouble, value}
+}
+func MakeDbValueDecimal(value string) DbValue {
+	return DbValue{DbValueDecimal, value}
+}
+func MakeDbValueDate(value golem_rdbms_types.Date) DbValue {
+	return DbValue{DbValueDate, value}
+}
+func MakeDbValueDatetime(value golem_rdbms_types.Timestamp) DbValue {
+	return DbValue{DbValueDatetime, value}
+}
+func MakeDbValueTimestamp(value golem_rdbms_types.Timestamp) DbValue {
+	return DbValue{DbValueTimestamp, value}
+}
+func MakeDbValueTime(value golem_rdbms_types.Time) DbValue {
+	return DbValue{DbValueTime, value}
+}
+func MakeDbValueYear(value uint16) DbValue {
+	return DbValue{DbValueYear, value}
+}
+func MakeDbValueFixchar(value string) DbValue {
+	return DbValue{DbValueFixchar, value}
+}
+func MakeDbValueVarchar(value string) DbValue {
+	return DbValue{DbValueVarchar, value}
+}
+func MakeDbValueTinytext(value string) DbValue {
+	return DbValue{DbValueTinytext, value}
+}
+func MakeDbValueText(value string) DbValue {
+	return DbValue{DbValueText, value}
+}
+func MakeDbValueMediumtext(value string) DbValue {
+	return DbValue{DbValueMediumtext, value}
+}
+func MakeDbValueLongtext(value string) DbValue {
+	return DbValue{DbValueLongtext, value}
+}
+func MakeDbValueBinary(value []uint8) DbValue {
+	return DbValue{DbValueBinary, value}
+}
+func MakeDbValueVarbinary(value []uint8) DbValue {
+	return DbValue{DbValueVarbinary, value}
+}
+func MakeDbValueTinyblob(value []uint8) DbValue {
+	return DbValue{DbValueTinyblob, value}
+}
+func MakeDbValueBlob(value []uint8) DbValue {
+	return DbValue{DbValueBlob, value}
+}
+func MakeDbValueMediumblob(value []uint8) DbValue {
+	return DbValue{DbValueMediumblob, value}
+}
+func MakeDbValueLongblob(value []uint8) DbValue {
+	return DbValue{DbValueLongblob, value}
+}
+func MakeDbValueEnumeration(value string) DbValue {
+	return DbValue{DbValueEnumeration, value}
+}
+func MakeDbValueSet(value string) DbValue {
+	return DbValue{DbValueSet, value}
+}
+func MakeDbValueBit(value []bool) DbValue {
+	return DbValue{DbValueBit, value}
+}
+func MakeDbValueJson(value string) DbValue {
+	return DbValue{DbValueJson, value}
+}
+func MakeDbValueNull() DbValue {
+	return DbValue{DbValueNull, nil}
+}
+
+// A single row of values
+type DbRow struct {
+	Values []DbValue
+}
+
+type DbResult struct {
+	Columns []DbColumn
+	Rows    []DbRow
+}
+
+//go:wasmimport golem:rdbms/mysql@1.5.0 [resource-drop]db-result-stream
+func resourceDropDbResultStream(handle int32)
+
+// A potentially very large and lazy stream of rows:
+type DbResultStream struct {
+	handle *witRuntime.Handle
+}
+
+func (self *DbResultStream) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *DbResultStream) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *DbResultStream) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *DbResultStream) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropDbResultStream(handle)
+	}
+}
+
+func DbResultStreamFromOwnHandle(handleValue int32) *DbResultStream {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &DbResultStream{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropDbResultStream(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func DbResultStreamFromBorrowHandle(handleValue int32) *DbResultStream {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &DbResultStream{handle}
+}
+
+//go:wasmimport golem:rdbms/mysql@1.5.0 [resource-drop]db-connection
+func resourceDropDbConnection(handle int32)
+
+type DbConnection struct {
+	handle *witRuntime.Handle
+}
+
+func (self *DbConnection) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *DbConnection) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *DbConnection) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *DbConnection) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropDbConnection(handle)
+	}
+}
+
+func DbConnectionFromOwnHandle(handleValue int32) *DbConnection {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &DbConnection{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropDbConnection(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func DbConnectionFromBorrowHandle(handleValue int32) *DbConnection {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &DbConnection{handle}
+}
+
+//go:wasmimport golem:rdbms/mysql@1.5.0 [resource-drop]db-transaction
+func resourceDropDbTransaction(handle int32)
+
+type DbTransaction struct {
+	handle *witRuntime.Handle
+}
+
+func (self *DbTransaction) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *DbTransaction) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *DbTransaction) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *DbTransaction) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropDbTransaction(handle)
+	}
+}
+
+func DbTransactionFromOwnHandle(handleValue int32) *DbTransaction {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &DbTransaction{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropDbTransaction(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func DbTransactionFromBorrowHandle(handleValue int32) *DbTransaction {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &DbTransaction{handle}
+}
+
+//go:wasmimport golem:rdbms/mysql@1.5.0 [method]db-result-stream.get-columns
+func wasm_import_method_db_result_stream_get_columns(arg0 int32, arg1 uintptr)
+
+func (self *DbResultStream) GetColumns() []DbColumn {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	wasm_import_method_db_result_stream_get_columns((self).Handle(), returnArea)
+	result := make([]DbColumn, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)))), index*(16+4*4))
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+		var variant DbColumnType
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+		case 0:
+
+			variant = MakeDbColumnTypeBoolean()
+
+		case 1:
+
+			variant = MakeDbColumnTypeTinyint()
+
+		case 2:
+
+			variant = MakeDbColumnTypeSmallint()
+
+		case 3:
+
+			variant = MakeDbColumnTypeMediumint()
+
+		case 4:
+
+			variant = MakeDbColumnTypeInt()
+
+		case 5:
+
+			variant = MakeDbColumnTypeBigint()
+
+		case 6:
+
+			variant = MakeDbColumnTypeTinyintUnsigned()
+
+		case 7:
+
+			variant = MakeDbColumnTypeSmallintUnsigned()
+
+		case 8:
+
+			variant = MakeDbColumnTypeMediumintUnsigned()
+
+		case 9:
+
+			variant = MakeDbColumnTypeIntUnsigned()
+
+		case 10:
+
+			variant = MakeDbColumnTypeBigintUnsigned()
+
+		case 11:
+
+			variant = MakeDbColumnTypeFloat()
+
+		case 12:
+
+			variant = MakeDbColumnTypeDouble()
+
+		case 13:
+
+			variant = MakeDbColumnTypeDecimal()
+
+		case 14:
+
+			variant = MakeDbColumnTypeDate()
+
+		case 15:
+
+			variant = MakeDbColumnTypeDatetime()
+
+		case 16:
+
+			variant = MakeDbColumnTypeTimestamp()
+
+		case 17:
+
+			variant = MakeDbColumnTypeTime()
+
+		case 18:
+
+			variant = MakeDbColumnTypeYear()
+
+		case 19:
+
+			variant = MakeDbColumnTypeFixchar()
+
+		case 20:
+
+			variant = MakeDbColumnTypeVarchar()
+
+		case 21:
+
+			variant = MakeDbColumnTypeTinytext()
+
+		case 22:
+
+			variant = MakeDbColumnTypeText()
+
+		case 23:
+
+			variant = MakeDbColumnTypeMediumtext()
+
+		case 24:
+
+			variant = MakeDbColumnTypeLongtext()
+
+		case 25:
+
+			variant = MakeDbColumnTypeBinary()
+
+		case 26:
+
+			variant = MakeDbColumnTypeVarbinary()
+
+		case 27:
+
+			variant = MakeDbColumnTypeTinyblob()
+
+		case 28:
+
+			variant = MakeDbColumnTypeBlob()
+
+		case 29:
+
+			variant = MakeDbColumnTypeMediumblob()
+
+		case 30:
+
+			variant = MakeDbColumnTypeLongblob()
+
+		case 31:
+
+			variant = MakeDbColumnTypeEnumeration()
+
+		case 32:
+
+			variant = MakeDbColumnTypeSet()
+
+		case 33:
+
+			variant = MakeDbColumnTypeBit()
+
+		case 34:
+
+			variant = MakeDbColumnTypeJson()
+
+		default:
+			panic("unreachable")
+		}
+		value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+		result = append(result, DbColumn{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), value, variant, value0})
+	}
+
+	result1 := result
+	return result1
+
+}
+
+//go:wasmimport golem:rdbms/mysql@1.5.0 [method]db-result-stream.get-next
+func wasm_import_method_db_result_stream_get_next(arg0 int32, arg1 uintptr)
+
+func (self *DbResultStream) GetNext() witTypes.Option[[]DbRow] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_method_db_result_stream_get_next((self).Handle(), returnArea)
+	var option witTypes.Option[[]DbRow]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[[]DbRow]()
+	case 1:
+		result16 := make([]DbRow, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(2*4))
+			result15 := make([]DbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*24)
+				var variant DbValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant = MakeDbValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+				case 1:
+
+					variant = MakeDbValueTinyint(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 2:
+
+					variant = MakeDbValueSmallint(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 3:
+
+					variant = MakeDbValueMediumint(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 4:
+
+					variant = MakeDbValueInt(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 5:
+
+					variant = MakeDbValueBigint(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 6:
+
+					variant = MakeDbValueTinyintUnsigned(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 7:
+
+					variant = MakeDbValueSmallintUnsigned(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 8:
+
+					variant = MakeDbValueMediumintUnsigned(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 9:
+
+					variant = MakeDbValueIntUnsigned(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 10:
+
+					variant = MakeDbValueBigintUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 11:
+
+					variant = MakeDbValueFloat(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 12:
+
+					variant = MakeDbValueDouble(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 13:
+					value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueDecimal(value)
+
+				case 14:
+
+					variant = MakeDbValueDate(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))})
+
+				case 15:
+
+					variant = MakeDbValueDatetime(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))}})
+
+				case 16:
+
+					variant = MakeDbValueTimestamp(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))}})
+
+				case 17:
+
+					variant = MakeDbValueTime(golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+				case 18:
+
+					variant = MakeDbValueYear(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 19:
+					value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueFixchar(value0)
+
+				case 20:
+					value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueVarchar(value1)
+
+				case 21:
+					value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueTinytext(value2)
+
+				case 22:
+					value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueText(value3)
+
+				case 23:
+					value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueMediumtext(value4)
+
+				case 24:
+					value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueLongtext(value5)
+
+				case 25:
+					value6 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueBinary(value6)
+
+				case 26:
+					value7 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueVarbinary(value7)
+
+				case 27:
+					value8 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueTinyblob(value8)
+
+				case 28:
+					value9 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueBlob(value9)
+
+				case 29:
+					value10 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueMediumblob(value10)
+
+				case 30:
+					value11 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueLongblob(value11)
+
+				case 31:
+					value12 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueEnumeration(value12)
+
+				case 32:
+					value13 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueSet(value13)
+
+				case 33:
+					result := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+						result = append(result, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+					}
+
+					variant = MakeDbValueBit(result)
+
+				case 34:
+					value14 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant = MakeDbValueJson(value14)
+
+				case 35:
+
+					variant = MakeDbValueNull()
+
+				default:
+					panic("unreachable")
+				}
+
+				result15 = append(result15, variant)
+			}
+
+			result16 = append(result16, DbRow{result15})
+		}
+
+		option = witTypes.Some[[]DbRow](result16)
+	default:
+		panic("unreachable")
+	}
+	result17 := option
+	return result17
+
+}
+
+//go:wasmimport golem:rdbms/mysql@1.5.0 [static]db-connection.open
+func wasm_import_static_db_connection_open(arg0 uintptr, arg1 uint32, arg2 uintptr)
+
+func DbConnectionOpen(address string) witTypes.Result[*DbConnection, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(address))
+	pinner.Pin(utf8)
+	wasm_import_static_db_connection_open(uintptr(utf8), uint32(len(address)), returnArea)
+	var result witTypes.Result[*DbConnection, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[*DbConnection, Error](DbConnectionFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value0)
+
+		case 2:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value1)
+
+		case 3:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value2)
+
+		case 4:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value3)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[*DbConnection, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result4 := result
+	return result4
+
+}
+
+//go:wasmimport golem:rdbms/mysql@1.5.0 [method]db-connection.query
+func wasm_import_method_db_connection_query(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbConnection) Query(statement string, params []DbValue) witTypes.Result[DbResult, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice17 := params
+	length19 := uint32(len(slice17))
+	result18 := witRuntime.Allocate(pinner, uintptr(length19*24), 8)
+	for index, element := range slice17 {
+		base := unsafe.Add(result18, index*24)
+
+		switch element.Tag() {
+		case DbValueBoolean:
+			payload := element.Boolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueTinyint:
+			payload := element.Tinyint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueSmallint:
+			payload := element.Smallint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueMediumint:
+			payload := element.Mediumint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueInt:
+			payload := element.Int()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueBigint:
+			payload := element.Bigint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueTinyintUnsigned:
+			payload := element.TinyintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueSmallintUnsigned:
+			payload := element.SmallintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueMediumintUnsigned:
+			payload := element.MediumintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueIntUnsigned:
+			payload := element.IntUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueBigintUnsigned:
+			payload := element.BigintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case DbValueFloat:
+			payload := element.Float()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDouble:
+			payload := element.Double()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDecimal:
+			payload := element.Decimal()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueDate:
+			payload := element.Date()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).Day))
+
+		case DbValueDatetime:
+			payload := element.Datetime()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTimestamp:
+			payload := element.Timestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTime:
+			payload := element.Time()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Nanosecond)
+
+		case DbValueYear:
+			payload := element.Year()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueFixchar:
+			payload := element.Fixchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueVarchar:
+			payload := element.Varchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			utf82 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf82)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf82)))
+
+		case DbValueTinytext:
+			payload := element.Tinytext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			utf83 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf83)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf83)))
+
+		case DbValueText:
+			payload := element.Text()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			utf84 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf84)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf84)))
+
+		case DbValueMediumtext:
+			payload := element.Mediumtext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+			utf85 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf85)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf85)))
+
+		case DbValueLongtext:
+			payload := element.Longtext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+			utf86 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf86)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf86)))
+
+		case DbValueBinary:
+			payload := element.Binary()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		case DbValueVarbinary:
+			payload := element.Varbinary()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			data7 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data7)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data7)))
+
+		case DbValueTinyblob:
+			payload := element.Tinyblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			data8 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data8)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data8)))
+
+		case DbValueBlob:
+			payload := element.Blob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+			data9 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data9)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data9)))
+
+		case DbValueMediumblob:
+			payload := element.Mediumblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+			data10 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data10)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data10)))
+
+		case DbValueLongblob:
+			payload := element.Longblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			data11 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data11)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data11)))
+
+		case DbValueEnumeration:
+			payload := element.Enumeration()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			utf812 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf812)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf812)))
+
+		case DbValueSet:
+			payload := element.Set()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			utf813 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf813)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf813)))
+
+		case DbValueBit:
+			payload := element.Bit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+			slice := payload
+			length := uint32(len(slice))
+			result15 := witRuntime.Allocate(pinner, uintptr(length*1), 1)
+			for index, element := range slice {
+				base := unsafe.Add(result15, index*1)
+				var result14 int32
+				if element {
+					result14 = 1
+				} else {
+					result14 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result14)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result15)))
+
+		case DbValueJson:
+			payload := element.Json()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+			utf816 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf816)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf816)))
+
+		case DbValueNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_connection_query((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result18), length19, returnArea)
+	var result48 witTypes.Result[DbResult, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		result21 := make([]DbColumn, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(16+4*4))
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			var variant DbColumnType
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+			case 0:
+
+				variant = MakeDbColumnTypeBoolean()
+
+			case 1:
+
+				variant = MakeDbColumnTypeTinyint()
+
+			case 2:
+
+				variant = MakeDbColumnTypeSmallint()
+
+			case 3:
+
+				variant = MakeDbColumnTypeMediumint()
+
+			case 4:
+
+				variant = MakeDbColumnTypeInt()
+
+			case 5:
+
+				variant = MakeDbColumnTypeBigint()
+
+			case 6:
+
+				variant = MakeDbColumnTypeTinyintUnsigned()
+
+			case 7:
+
+				variant = MakeDbColumnTypeSmallintUnsigned()
+
+			case 8:
+
+				variant = MakeDbColumnTypeMediumintUnsigned()
+
+			case 9:
+
+				variant = MakeDbColumnTypeIntUnsigned()
+
+			case 10:
+
+				variant = MakeDbColumnTypeBigintUnsigned()
+
+			case 11:
+
+				variant = MakeDbColumnTypeFloat()
+
+			case 12:
+
+				variant = MakeDbColumnTypeDouble()
+
+			case 13:
+
+				variant = MakeDbColumnTypeDecimal()
+
+			case 14:
+
+				variant = MakeDbColumnTypeDate()
+
+			case 15:
+
+				variant = MakeDbColumnTypeDatetime()
+
+			case 16:
+
+				variant = MakeDbColumnTypeTimestamp()
+
+			case 17:
+
+				variant = MakeDbColumnTypeTime()
+
+			case 18:
+
+				variant = MakeDbColumnTypeYear()
+
+			case 19:
+
+				variant = MakeDbColumnTypeFixchar()
+
+			case 20:
+
+				variant = MakeDbColumnTypeVarchar()
+
+			case 21:
+
+				variant = MakeDbColumnTypeTinytext()
+
+			case 22:
+
+				variant = MakeDbColumnTypeText()
+
+			case 23:
+
+				variant = MakeDbColumnTypeMediumtext()
+
+			case 24:
+
+				variant = MakeDbColumnTypeLongtext()
+
+			case 25:
+
+				variant = MakeDbColumnTypeBinary()
+
+			case 26:
+
+				variant = MakeDbColumnTypeVarbinary()
+
+			case 27:
+
+				variant = MakeDbColumnTypeTinyblob()
+
+			case 28:
+
+				variant = MakeDbColumnTypeBlob()
+
+			case 29:
+
+				variant = MakeDbColumnTypeMediumblob()
+
+			case 30:
+
+				variant = MakeDbColumnTypeLongblob()
+
+			case 31:
+
+				variant = MakeDbColumnTypeEnumeration()
+
+			case 32:
+
+				variant = MakeDbColumnTypeSet()
+
+			case 33:
+
+				variant = MakeDbColumnTypeBit()
+
+			case 34:
+
+				variant = MakeDbColumnTypeJson()
+
+			default:
+				panic("unreachable")
+			}
+			value20 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+			result21 = append(result21, DbColumn{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), value, variant, value20})
+		}
+
+		result41 := make([]DbRow, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))), index*(2*4))
+			result40 := make([]DbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*24)
+				var variant39 DbValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant39 = MakeDbValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+				case 1:
+
+					variant39 = MakeDbValueTinyint(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 2:
+
+					variant39 = MakeDbValueSmallint(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 3:
+
+					variant39 = MakeDbValueMediumint(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 4:
+
+					variant39 = MakeDbValueInt(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 5:
+
+					variant39 = MakeDbValueBigint(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 6:
+
+					variant39 = MakeDbValueTinyintUnsigned(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 7:
+
+					variant39 = MakeDbValueSmallintUnsigned(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 8:
+
+					variant39 = MakeDbValueMediumintUnsigned(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 9:
+
+					variant39 = MakeDbValueIntUnsigned(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 10:
+
+					variant39 = MakeDbValueBigintUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 11:
+
+					variant39 = MakeDbValueFloat(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 12:
+
+					variant39 = MakeDbValueDouble(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 13:
+					value22 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueDecimal(value22)
+
+				case 14:
+
+					variant39 = MakeDbValueDate(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))})
+
+				case 15:
+
+					variant39 = MakeDbValueDatetime(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))}})
+
+				case 16:
+
+					variant39 = MakeDbValueTimestamp(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))}})
+
+				case 17:
+
+					variant39 = MakeDbValueTime(golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+				case 18:
+
+					variant39 = MakeDbValueYear(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 19:
+					value23 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueFixchar(value23)
+
+				case 20:
+					value24 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueVarchar(value24)
+
+				case 21:
+					value25 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueTinytext(value25)
+
+				case 22:
+					value26 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueText(value26)
+
+				case 23:
+					value27 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueMediumtext(value27)
+
+				case 24:
+					value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueLongtext(value28)
+
+				case 25:
+					value29 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueBinary(value29)
+
+				case 26:
+					value30 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueVarbinary(value30)
+
+				case 27:
+					value31 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueTinyblob(value31)
+
+				case 28:
+					value32 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueBlob(value32)
+
+				case 29:
+					value33 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueMediumblob(value33)
+
+				case 30:
+					value34 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueLongblob(value34)
+
+				case 31:
+					value35 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueEnumeration(value35)
+
+				case 32:
+					value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueSet(value36)
+
+				case 33:
+					result37 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+						result37 = append(result37, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+					}
+
+					variant39 = MakeDbValueBit(result37)
+
+				case 34:
+					value38 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueJson(value38)
+
+				case 35:
+
+					variant39 = MakeDbValueNull()
+
+				default:
+					panic("unreachable")
+				}
+
+				result40 = append(result40, variant39)
+			}
+
+			result41 = append(result41, DbRow{result40})
+		}
+
+		result48 = witTypes.Ok[DbResult, Error](DbResult{result21, result41})
+	case 1:
+		var variant47 Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value42 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant47 = MakeErrorConnectionFailure(value42)
+
+		case 1:
+			value43 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant47 = MakeErrorQueryParameterFailure(value43)
+
+		case 2:
+			value44 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant47 = MakeErrorQueryExecutionFailure(value44)
+
+		case 3:
+			value45 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant47 = MakeErrorQueryResponseFailure(value45)
+
+		case 4:
+			value46 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant47 = MakeErrorOther(value46)
+
+		default:
+			panic("unreachable")
+		}
+
+		result48 = witTypes.Err[DbResult, Error](variant47)
+	default:
+		panic("unreachable")
+	}
+	result49 := result48
+	return result49
+
+}
+
+//go:wasmimport golem:rdbms/mysql@1.5.0 [method]db-connection.query-stream
+func wasm_import_method_db_connection_query_stream(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbConnection) QueryStream(statement string, params []DbValue) witTypes.Result[*DbResultStream, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice17 := params
+	length19 := uint32(len(slice17))
+	result18 := witRuntime.Allocate(pinner, uintptr(length19*24), 8)
+	for index, element := range slice17 {
+		base := unsafe.Add(result18, index*24)
+
+		switch element.Tag() {
+		case DbValueBoolean:
+			payload := element.Boolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueTinyint:
+			payload := element.Tinyint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueSmallint:
+			payload := element.Smallint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueMediumint:
+			payload := element.Mediumint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueInt:
+			payload := element.Int()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueBigint:
+			payload := element.Bigint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueTinyintUnsigned:
+			payload := element.TinyintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueSmallintUnsigned:
+			payload := element.SmallintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueMediumintUnsigned:
+			payload := element.MediumintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueIntUnsigned:
+			payload := element.IntUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueBigintUnsigned:
+			payload := element.BigintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case DbValueFloat:
+			payload := element.Float()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDouble:
+			payload := element.Double()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDecimal:
+			payload := element.Decimal()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueDate:
+			payload := element.Date()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).Day))
+
+		case DbValueDatetime:
+			payload := element.Datetime()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTimestamp:
+			payload := element.Timestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTime:
+			payload := element.Time()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Nanosecond)
+
+		case DbValueYear:
+			payload := element.Year()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueFixchar:
+			payload := element.Fixchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueVarchar:
+			payload := element.Varchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			utf82 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf82)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf82)))
+
+		case DbValueTinytext:
+			payload := element.Tinytext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			utf83 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf83)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf83)))
+
+		case DbValueText:
+			payload := element.Text()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			utf84 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf84)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf84)))
+
+		case DbValueMediumtext:
+			payload := element.Mediumtext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+			utf85 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf85)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf85)))
+
+		case DbValueLongtext:
+			payload := element.Longtext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+			utf86 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf86)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf86)))
+
+		case DbValueBinary:
+			payload := element.Binary()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		case DbValueVarbinary:
+			payload := element.Varbinary()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			data7 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data7)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data7)))
+
+		case DbValueTinyblob:
+			payload := element.Tinyblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			data8 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data8)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data8)))
+
+		case DbValueBlob:
+			payload := element.Blob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+			data9 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data9)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data9)))
+
+		case DbValueMediumblob:
+			payload := element.Mediumblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+			data10 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data10)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data10)))
+
+		case DbValueLongblob:
+			payload := element.Longblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			data11 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data11)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data11)))
+
+		case DbValueEnumeration:
+			payload := element.Enumeration()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			utf812 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf812)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf812)))
+
+		case DbValueSet:
+			payload := element.Set()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			utf813 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf813)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf813)))
+
+		case DbValueBit:
+			payload := element.Bit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+			slice := payload
+			length := uint32(len(slice))
+			result15 := witRuntime.Allocate(pinner, uintptr(length*1), 1)
+			for index, element := range slice {
+				base := unsafe.Add(result15, index*1)
+				var result14 int32
+				if element {
+					result14 = 1
+				} else {
+					result14 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result14)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result15)))
+
+		case DbValueJson:
+			payload := element.Json()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+			utf816 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf816)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf816)))
+
+		case DbValueNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_connection_query_stream((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result18), length19, returnArea)
+	var result24 witTypes.Result[*DbResultStream, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result24 = witTypes.Ok[*DbResultStream, Error](DbResultStreamFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value20 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value20)
+
+		case 2:
+			value21 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value21)
+
+		case 3:
+			value22 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value22)
+
+		case 4:
+			value23 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value23)
+
+		default:
+			panic("unreachable")
+		}
+
+		result24 = witTypes.Err[*DbResultStream, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result25 := result24
+	return result25
+
+}
+
+//go:wasmimport golem:rdbms/mysql@1.5.0 [method]db-connection.execute
+func wasm_import_method_db_connection_execute(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbConnection) Execute(statement string, params []DbValue) witTypes.Result[uint64, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (16 + 2*4), 8))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice17 := params
+	length19 := uint32(len(slice17))
+	result18 := witRuntime.Allocate(pinner, uintptr(length19*24), 8)
+	for index, element := range slice17 {
+		base := unsafe.Add(result18, index*24)
+
+		switch element.Tag() {
+		case DbValueBoolean:
+			payload := element.Boolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueTinyint:
+			payload := element.Tinyint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueSmallint:
+			payload := element.Smallint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueMediumint:
+			payload := element.Mediumint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueInt:
+			payload := element.Int()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueBigint:
+			payload := element.Bigint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueTinyintUnsigned:
+			payload := element.TinyintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueSmallintUnsigned:
+			payload := element.SmallintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueMediumintUnsigned:
+			payload := element.MediumintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueIntUnsigned:
+			payload := element.IntUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueBigintUnsigned:
+			payload := element.BigintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case DbValueFloat:
+			payload := element.Float()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDouble:
+			payload := element.Double()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDecimal:
+			payload := element.Decimal()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueDate:
+			payload := element.Date()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).Day))
+
+		case DbValueDatetime:
+			payload := element.Datetime()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTimestamp:
+			payload := element.Timestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTime:
+			payload := element.Time()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Nanosecond)
+
+		case DbValueYear:
+			payload := element.Year()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueFixchar:
+			payload := element.Fixchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueVarchar:
+			payload := element.Varchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			utf82 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf82)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf82)))
+
+		case DbValueTinytext:
+			payload := element.Tinytext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			utf83 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf83)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf83)))
+
+		case DbValueText:
+			payload := element.Text()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			utf84 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf84)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf84)))
+
+		case DbValueMediumtext:
+			payload := element.Mediumtext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+			utf85 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf85)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf85)))
+
+		case DbValueLongtext:
+			payload := element.Longtext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+			utf86 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf86)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf86)))
+
+		case DbValueBinary:
+			payload := element.Binary()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		case DbValueVarbinary:
+			payload := element.Varbinary()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			data7 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data7)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data7)))
+
+		case DbValueTinyblob:
+			payload := element.Tinyblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			data8 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data8)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data8)))
+
+		case DbValueBlob:
+			payload := element.Blob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+			data9 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data9)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data9)))
+
+		case DbValueMediumblob:
+			payload := element.Mediumblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+			data10 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data10)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data10)))
+
+		case DbValueLongblob:
+			payload := element.Longblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			data11 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data11)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data11)))
+
+		case DbValueEnumeration:
+			payload := element.Enumeration()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			utf812 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf812)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf812)))
+
+		case DbValueSet:
+			payload := element.Set()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			utf813 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf813)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf813)))
+
+		case DbValueBit:
+			payload := element.Bit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+			slice := payload
+			length := uint32(len(slice))
+			result15 := witRuntime.Allocate(pinner, uintptr(length*1), 1)
+			for index, element := range slice {
+				base := unsafe.Add(result15, index*1)
+				var result14 int32
+				if element {
+					result14 = 1
+				} else {
+					result14 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result14)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result15)))
+
+		case DbValueJson:
+			payload := element.Json()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+			utf816 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf816)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf816)))
+
+		case DbValueNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_connection_execute((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result18), length19, returnArea)
+	var result24 witTypes.Result[uint64, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result24 = witTypes.Ok[uint64, Error](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value20 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryParameterFailure(value20)
+
+		case 2:
+			value21 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryExecutionFailure(value21)
+
+		case 3:
+			value22 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryResponseFailure(value22)
+
+		case 4:
+			value23 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorOther(value23)
+
+		default:
+			panic("unreachable")
+		}
+
+		result24 = witTypes.Err[uint64, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result25 := result24
+	return result25
+
+}
+
+//go:wasmimport golem:rdbms/mysql@1.5.0 [method]db-connection.begin-transaction
+func wasm_import_method_db_connection_begin_transaction(arg0 int32, arg1 uintptr)
+
+func (self *DbConnection) BeginTransaction() witTypes.Result[*DbTransaction, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	wasm_import_method_db_connection_begin_transaction((self).Handle(), returnArea)
+	var result witTypes.Result[*DbTransaction, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[*DbTransaction, Error](DbTransactionFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value0)
+
+		case 2:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value1)
+
+		case 3:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value2)
+
+		case 4:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value3)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[*DbTransaction, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result4 := result
+	return result4
+
+}
+
+//go:wasmimport golem:rdbms/mysql@1.5.0 [method]db-transaction.query
+func wasm_import_method_db_transaction_query(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbTransaction) Query(statement string, params []DbValue) witTypes.Result[DbResult, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice17 := params
+	length19 := uint32(len(slice17))
+	result18 := witRuntime.Allocate(pinner, uintptr(length19*24), 8)
+	for index, element := range slice17 {
+		base := unsafe.Add(result18, index*24)
+
+		switch element.Tag() {
+		case DbValueBoolean:
+			payload := element.Boolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueTinyint:
+			payload := element.Tinyint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueSmallint:
+			payload := element.Smallint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueMediumint:
+			payload := element.Mediumint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueInt:
+			payload := element.Int()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueBigint:
+			payload := element.Bigint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueTinyintUnsigned:
+			payload := element.TinyintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueSmallintUnsigned:
+			payload := element.SmallintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueMediumintUnsigned:
+			payload := element.MediumintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueIntUnsigned:
+			payload := element.IntUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueBigintUnsigned:
+			payload := element.BigintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case DbValueFloat:
+			payload := element.Float()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDouble:
+			payload := element.Double()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDecimal:
+			payload := element.Decimal()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueDate:
+			payload := element.Date()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).Day))
+
+		case DbValueDatetime:
+			payload := element.Datetime()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTimestamp:
+			payload := element.Timestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTime:
+			payload := element.Time()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Nanosecond)
+
+		case DbValueYear:
+			payload := element.Year()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueFixchar:
+			payload := element.Fixchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueVarchar:
+			payload := element.Varchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			utf82 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf82)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf82)))
+
+		case DbValueTinytext:
+			payload := element.Tinytext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			utf83 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf83)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf83)))
+
+		case DbValueText:
+			payload := element.Text()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			utf84 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf84)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf84)))
+
+		case DbValueMediumtext:
+			payload := element.Mediumtext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+			utf85 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf85)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf85)))
+
+		case DbValueLongtext:
+			payload := element.Longtext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+			utf86 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf86)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf86)))
+
+		case DbValueBinary:
+			payload := element.Binary()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		case DbValueVarbinary:
+			payload := element.Varbinary()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			data7 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data7)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data7)))
+
+		case DbValueTinyblob:
+			payload := element.Tinyblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			data8 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data8)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data8)))
+
+		case DbValueBlob:
+			payload := element.Blob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+			data9 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data9)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data9)))
+
+		case DbValueMediumblob:
+			payload := element.Mediumblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+			data10 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data10)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data10)))
+
+		case DbValueLongblob:
+			payload := element.Longblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			data11 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data11)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data11)))
+
+		case DbValueEnumeration:
+			payload := element.Enumeration()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			utf812 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf812)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf812)))
+
+		case DbValueSet:
+			payload := element.Set()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			utf813 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf813)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf813)))
+
+		case DbValueBit:
+			payload := element.Bit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+			slice := payload
+			length := uint32(len(slice))
+			result15 := witRuntime.Allocate(pinner, uintptr(length*1), 1)
+			for index, element := range slice {
+				base := unsafe.Add(result15, index*1)
+				var result14 int32
+				if element {
+					result14 = 1
+				} else {
+					result14 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result14)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result15)))
+
+		case DbValueJson:
+			payload := element.Json()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+			utf816 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf816)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf816)))
+
+		case DbValueNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_transaction_query((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result18), length19, returnArea)
+	var result48 witTypes.Result[DbResult, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		result21 := make([]DbColumn, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(16+4*4))
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			var variant DbColumnType
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+			case 0:
+
+				variant = MakeDbColumnTypeBoolean()
+
+			case 1:
+
+				variant = MakeDbColumnTypeTinyint()
+
+			case 2:
+
+				variant = MakeDbColumnTypeSmallint()
+
+			case 3:
+
+				variant = MakeDbColumnTypeMediumint()
+
+			case 4:
+
+				variant = MakeDbColumnTypeInt()
+
+			case 5:
+
+				variant = MakeDbColumnTypeBigint()
+
+			case 6:
+
+				variant = MakeDbColumnTypeTinyintUnsigned()
+
+			case 7:
+
+				variant = MakeDbColumnTypeSmallintUnsigned()
+
+			case 8:
+
+				variant = MakeDbColumnTypeMediumintUnsigned()
+
+			case 9:
+
+				variant = MakeDbColumnTypeIntUnsigned()
+
+			case 10:
+
+				variant = MakeDbColumnTypeBigintUnsigned()
+
+			case 11:
+
+				variant = MakeDbColumnTypeFloat()
+
+			case 12:
+
+				variant = MakeDbColumnTypeDouble()
+
+			case 13:
+
+				variant = MakeDbColumnTypeDecimal()
+
+			case 14:
+
+				variant = MakeDbColumnTypeDate()
+
+			case 15:
+
+				variant = MakeDbColumnTypeDatetime()
+
+			case 16:
+
+				variant = MakeDbColumnTypeTimestamp()
+
+			case 17:
+
+				variant = MakeDbColumnTypeTime()
+
+			case 18:
+
+				variant = MakeDbColumnTypeYear()
+
+			case 19:
+
+				variant = MakeDbColumnTypeFixchar()
+
+			case 20:
+
+				variant = MakeDbColumnTypeVarchar()
+
+			case 21:
+
+				variant = MakeDbColumnTypeTinytext()
+
+			case 22:
+
+				variant = MakeDbColumnTypeText()
+
+			case 23:
+
+				variant = MakeDbColumnTypeMediumtext()
+
+			case 24:
+
+				variant = MakeDbColumnTypeLongtext()
+
+			case 25:
+
+				variant = MakeDbColumnTypeBinary()
+
+			case 26:
+
+				variant = MakeDbColumnTypeVarbinary()
+
+			case 27:
+
+				variant = MakeDbColumnTypeTinyblob()
+
+			case 28:
+
+				variant = MakeDbColumnTypeBlob()
+
+			case 29:
+
+				variant = MakeDbColumnTypeMediumblob()
+
+			case 30:
+
+				variant = MakeDbColumnTypeLongblob()
+
+			case 31:
+
+				variant = MakeDbColumnTypeEnumeration()
+
+			case 32:
+
+				variant = MakeDbColumnTypeSet()
+
+			case 33:
+
+				variant = MakeDbColumnTypeBit()
+
+			case 34:
+
+				variant = MakeDbColumnTypeJson()
+
+			default:
+				panic("unreachable")
+			}
+			value20 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+			result21 = append(result21, DbColumn{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), value, variant, value20})
+		}
+
+		result41 := make([]DbRow, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))), index*(2*4))
+			result40 := make([]DbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*24)
+				var variant39 DbValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant39 = MakeDbValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+				case 1:
+
+					variant39 = MakeDbValueTinyint(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 2:
+
+					variant39 = MakeDbValueSmallint(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 3:
+
+					variant39 = MakeDbValueMediumint(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 4:
+
+					variant39 = MakeDbValueInt(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 5:
+
+					variant39 = MakeDbValueBigint(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 6:
+
+					variant39 = MakeDbValueTinyintUnsigned(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 7:
+
+					variant39 = MakeDbValueSmallintUnsigned(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 8:
+
+					variant39 = MakeDbValueMediumintUnsigned(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 9:
+
+					variant39 = MakeDbValueIntUnsigned(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 10:
+
+					variant39 = MakeDbValueBigintUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 11:
+
+					variant39 = MakeDbValueFloat(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 12:
+
+					variant39 = MakeDbValueDouble(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 13:
+					value22 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueDecimal(value22)
+
+				case 14:
+
+					variant39 = MakeDbValueDate(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))})
+
+				case 15:
+
+					variant39 = MakeDbValueDatetime(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))}})
+
+				case 16:
+
+					variant39 = MakeDbValueTimestamp(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))}})
+
+				case 17:
+
+					variant39 = MakeDbValueTime(golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+				case 18:
+
+					variant39 = MakeDbValueYear(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 19:
+					value23 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueFixchar(value23)
+
+				case 20:
+					value24 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueVarchar(value24)
+
+				case 21:
+					value25 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueTinytext(value25)
+
+				case 22:
+					value26 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueText(value26)
+
+				case 23:
+					value27 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueMediumtext(value27)
+
+				case 24:
+					value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueLongtext(value28)
+
+				case 25:
+					value29 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueBinary(value29)
+
+				case 26:
+					value30 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueVarbinary(value30)
+
+				case 27:
+					value31 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueTinyblob(value31)
+
+				case 28:
+					value32 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueBlob(value32)
+
+				case 29:
+					value33 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueMediumblob(value33)
+
+				case 30:
+					value34 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueLongblob(value34)
+
+				case 31:
+					value35 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueEnumeration(value35)
+
+				case 32:
+					value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueSet(value36)
+
+				case 33:
+					result37 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+						result37 = append(result37, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+					}
+
+					variant39 = MakeDbValueBit(result37)
+
+				case 34:
+					value38 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueJson(value38)
+
+				case 35:
+
+					variant39 = MakeDbValueNull()
+
+				default:
+					panic("unreachable")
+				}
+
+				result40 = append(result40, variant39)
+			}
+
+			result41 = append(result41, DbRow{result40})
+		}
+
+		result48 = witTypes.Ok[DbResult, Error](DbResult{result21, result41})
+	case 1:
+		var variant47 Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value42 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant47 = MakeErrorConnectionFailure(value42)
+
+		case 1:
+			value43 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant47 = MakeErrorQueryParameterFailure(value43)
+
+		case 2:
+			value44 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant47 = MakeErrorQueryExecutionFailure(value44)
+
+		case 3:
+			value45 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant47 = MakeErrorQueryResponseFailure(value45)
+
+		case 4:
+			value46 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant47 = MakeErrorOther(value46)
+
+		default:
+			panic("unreachable")
+		}
+
+		result48 = witTypes.Err[DbResult, Error](variant47)
+	default:
+		panic("unreachable")
+	}
+	result49 := result48
+	return result49
+
+}
+
+//go:wasmimport golem:rdbms/mysql@1.5.0 [method]db-transaction.query-stream
+func wasm_import_method_db_transaction_query_stream(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbTransaction) QueryStream(statement string, params []DbValue) witTypes.Result[*DbResultStream, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice17 := params
+	length19 := uint32(len(slice17))
+	result18 := witRuntime.Allocate(pinner, uintptr(length19*24), 8)
+	for index, element := range slice17 {
+		base := unsafe.Add(result18, index*24)
+
+		switch element.Tag() {
+		case DbValueBoolean:
+			payload := element.Boolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueTinyint:
+			payload := element.Tinyint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueSmallint:
+			payload := element.Smallint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueMediumint:
+			payload := element.Mediumint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueInt:
+			payload := element.Int()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueBigint:
+			payload := element.Bigint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueTinyintUnsigned:
+			payload := element.TinyintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueSmallintUnsigned:
+			payload := element.SmallintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueMediumintUnsigned:
+			payload := element.MediumintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueIntUnsigned:
+			payload := element.IntUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueBigintUnsigned:
+			payload := element.BigintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case DbValueFloat:
+			payload := element.Float()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDouble:
+			payload := element.Double()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDecimal:
+			payload := element.Decimal()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueDate:
+			payload := element.Date()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).Day))
+
+		case DbValueDatetime:
+			payload := element.Datetime()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTimestamp:
+			payload := element.Timestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTime:
+			payload := element.Time()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Nanosecond)
+
+		case DbValueYear:
+			payload := element.Year()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueFixchar:
+			payload := element.Fixchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueVarchar:
+			payload := element.Varchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			utf82 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf82)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf82)))
+
+		case DbValueTinytext:
+			payload := element.Tinytext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			utf83 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf83)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf83)))
+
+		case DbValueText:
+			payload := element.Text()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			utf84 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf84)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf84)))
+
+		case DbValueMediumtext:
+			payload := element.Mediumtext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+			utf85 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf85)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf85)))
+
+		case DbValueLongtext:
+			payload := element.Longtext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+			utf86 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf86)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf86)))
+
+		case DbValueBinary:
+			payload := element.Binary()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		case DbValueVarbinary:
+			payload := element.Varbinary()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			data7 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data7)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data7)))
+
+		case DbValueTinyblob:
+			payload := element.Tinyblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			data8 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data8)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data8)))
+
+		case DbValueBlob:
+			payload := element.Blob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+			data9 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data9)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data9)))
+
+		case DbValueMediumblob:
+			payload := element.Mediumblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+			data10 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data10)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data10)))
+
+		case DbValueLongblob:
+			payload := element.Longblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			data11 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data11)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data11)))
+
+		case DbValueEnumeration:
+			payload := element.Enumeration()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			utf812 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf812)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf812)))
+
+		case DbValueSet:
+			payload := element.Set()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			utf813 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf813)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf813)))
+
+		case DbValueBit:
+			payload := element.Bit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+			slice := payload
+			length := uint32(len(slice))
+			result15 := witRuntime.Allocate(pinner, uintptr(length*1), 1)
+			for index, element := range slice {
+				base := unsafe.Add(result15, index*1)
+				var result14 int32
+				if element {
+					result14 = 1
+				} else {
+					result14 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result14)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result15)))
+
+		case DbValueJson:
+			payload := element.Json()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+			utf816 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf816)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf816)))
+
+		case DbValueNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_transaction_query_stream((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result18), length19, returnArea)
+	var result24 witTypes.Result[*DbResultStream, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result24 = witTypes.Ok[*DbResultStream, Error](DbResultStreamFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value20 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value20)
+
+		case 2:
+			value21 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value21)
+
+		case 3:
+			value22 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value22)
+
+		case 4:
+			value23 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value23)
+
+		default:
+			panic("unreachable")
+		}
+
+		result24 = witTypes.Err[*DbResultStream, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result25 := result24
+	return result25
+
+}
+
+//go:wasmimport golem:rdbms/mysql@1.5.0 [method]db-transaction.execute
+func wasm_import_method_db_transaction_execute(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbTransaction) Execute(statement string, params []DbValue) witTypes.Result[uint64, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (16 + 2*4), 8))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice17 := params
+	length19 := uint32(len(slice17))
+	result18 := witRuntime.Allocate(pinner, uintptr(length19*24), 8)
+	for index, element := range slice17 {
+		base := unsafe.Add(result18, index*24)
+
+		switch element.Tag() {
+		case DbValueBoolean:
+			payload := element.Boolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueTinyint:
+			payload := element.Tinyint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueSmallint:
+			payload := element.Smallint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueMediumint:
+			payload := element.Mediumint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueInt:
+			payload := element.Int()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueBigint:
+			payload := element.Bigint()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueTinyintUnsigned:
+			payload := element.TinyintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueSmallintUnsigned:
+			payload := element.SmallintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueMediumintUnsigned:
+			payload := element.MediumintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueIntUnsigned:
+			payload := element.IntUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueBigintUnsigned:
+			payload := element.BigintUnsigned()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+		case DbValueFloat:
+			payload := element.Float()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDouble:
+			payload := element.Double()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueDecimal:
+			payload := element.Decimal()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueDate:
+			payload := element.Date()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).Day))
+
+		case DbValueDatetime:
+			payload := element.Datetime()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTimestamp:
+			payload := element.Timestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTime:
+			payload := element.Time()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Nanosecond)
+
+		case DbValueYear:
+			payload := element.Year()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueFixchar:
+			payload := element.Fixchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueVarchar:
+			payload := element.Varchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			utf82 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf82)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf82)))
+
+		case DbValueTinytext:
+			payload := element.Tinytext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			utf83 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf83)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf83)))
+
+		case DbValueText:
+			payload := element.Text()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			utf84 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf84)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf84)))
+
+		case DbValueMediumtext:
+			payload := element.Mediumtext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+			utf85 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf85)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf85)))
+
+		case DbValueLongtext:
+			payload := element.Longtext()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+			utf86 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf86)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf86)))
+
+		case DbValueBinary:
+			payload := element.Binary()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		case DbValueVarbinary:
+			payload := element.Varbinary()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			data7 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data7)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data7)))
+
+		case DbValueTinyblob:
+			payload := element.Tinyblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			data8 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data8)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data8)))
+
+		case DbValueBlob:
+			payload := element.Blob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+			data9 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data9)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data9)))
+
+		case DbValueMediumblob:
+			payload := element.Mediumblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+			data10 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data10)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data10)))
+
+		case DbValueLongblob:
+			payload := element.Longblob()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			data11 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data11)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data11)))
+
+		case DbValueEnumeration:
+			payload := element.Enumeration()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			utf812 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf812)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf812)))
+
+		case DbValueSet:
+			payload := element.Set()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			utf813 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf813)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf813)))
+
+		case DbValueBit:
+			payload := element.Bit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+			slice := payload
+			length := uint32(len(slice))
+			result15 := witRuntime.Allocate(pinner, uintptr(length*1), 1)
+			for index, element := range slice {
+				base := unsafe.Add(result15, index*1)
+				var result14 int32
+				if element {
+					result14 = 1
+				} else {
+					result14 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result14)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result15)))
+
+		case DbValueJson:
+			payload := element.Json()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+			utf816 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf816)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf816)))
+
+		case DbValueNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_transaction_execute((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result18), length19, returnArea)
+	var result24 witTypes.Result[uint64, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result24 = witTypes.Ok[uint64, Error](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value20 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryParameterFailure(value20)
+
+		case 2:
+			value21 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryExecutionFailure(value21)
+
+		case 3:
+			value22 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryResponseFailure(value22)
+
+		case 4:
+			value23 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorOther(value23)
+
+		default:
+			panic("unreachable")
+		}
+
+		result24 = witTypes.Err[uint64, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result25 := result24
+	return result25
+
+}
+
+//go:wasmimport golem:rdbms/mysql@1.5.0 [method]db-transaction.commit
+func wasm_import_method_db_transaction_commit(arg0 int32, arg1 uintptr)
+
+func (self *DbTransaction) Commit() witTypes.Result[witTypes.Unit, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	wasm_import_method_db_transaction_commit((self).Handle(), returnArea)
+	var result witTypes.Result[witTypes.Unit, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, Error](witTypes.Unit{})
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value0)
+
+		case 2:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value1)
+
+		case 3:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value2)
+
+		case 4:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value3)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Unit, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result4 := result
+	return result4
+
+}
+
+//go:wasmimport golem:rdbms/mysql@1.5.0 [method]db-transaction.rollback
+func wasm_import_method_db_transaction_rollback(arg0 int32, arg1 uintptr)
+
+func (self *DbTransaction) Rollback() witTypes.Result[witTypes.Unit, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	wasm_import_method_db_transaction_rollback((self).Handle(), returnArea)
+	var result witTypes.Result[witTypes.Unit, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, Error](witTypes.Unit{})
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value0)
+
+		case 2:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value1)
+
+		case 3:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value2)
+
+		case 4:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value3)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Unit, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result4 := result
+	return result4
+
+}
diff --git a/sdks/go/golem/internal/wit/golem_rdbms_postgres/empty.s b/sdks/go/golem/internal/wit/golem_rdbms_postgres/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_rdbms_postgres/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_rdbms_postgres/wit_bindings.go b/sdks/go/golem/internal/wit/golem_rdbms_postgres/wit_bindings.go
new file mode 100644
index 0000000000..29cb467ceb
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_rdbms_postgres/wit_bindings.go
@@ -0,0 +1,10569 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_rdbms_postgres
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_rdbms_types"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type Date = golem_rdbms_types.Date
+type Time = golem_rdbms_types.Time
+type Timetz = golem_rdbms_types.Timetz
+type Timestamp = golem_rdbms_types.Timestamp
+type Timestamptz = golem_rdbms_types.Timestamptz
+type Uuid = golem_rdbms_types.Uuid
+type IpAddress = golem_rdbms_types.IpAddress
+type MacAddress = golem_rdbms_types.MacAddress
+
+const (
+	ErrorConnectionFailure     uint8 = 0
+	ErrorQueryParameterFailure uint8 = 1
+	ErrorQueryExecutionFailure uint8 = 2
+	ErrorQueryResponseFailure  uint8 = 3
+	ErrorOther                 uint8 = 4
+)
+
+type Error struct {
+	tag   uint8
+	value any
+}
+
+func (self Error) Tag() uint8 {
+	return self.tag
+}
+
+func (self Error) ConnectionFailure() string {
+	if self.tag != ErrorConnectionFailure {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) QueryParameterFailure() string {
+	if self.tag != ErrorQueryParameterFailure {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) QueryExecutionFailure() string {
+	if self.tag != ErrorQueryExecutionFailure {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) QueryResponseFailure() string {
+	if self.tag != ErrorQueryResponseFailure {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) Other() string {
+	if self.tag != ErrorOther {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+
+func MakeErrorConnectionFailure(value string) Error {
+	return Error{ErrorConnectionFailure, value}
+}
+func MakeErrorQueryParameterFailure(value string) Error {
+	return Error{ErrorQueryParameterFailure, value}
+}
+func MakeErrorQueryExecutionFailure(value string) Error {
+	return Error{ErrorQueryExecutionFailure, value}
+}
+func MakeErrorQueryResponseFailure(value string) Error {
+	return Error{ErrorQueryResponseFailure, value}
+}
+func MakeErrorOther(value string) Error {
+	return Error{ErrorOther, value}
+}
+
+type Interval struct {
+	Months       int32
+	Days         int32
+	Microseconds int64
+}
+
+const (
+	Int4boundIncluded  uint8 = 0
+	Int4boundExcluded  uint8 = 1
+	Int4boundUnbounded uint8 = 2
+)
+
+type Int4bound struct {
+	tag   uint8
+	value any
+}
+
+func (self Int4bound) Tag() uint8 {
+	return self.tag
+}
+
+func (self Int4bound) Included() int32 {
+	if self.tag != Int4boundIncluded {
+		panic("tag mismatch")
+	}
+	return self.value.(int32)
+}
+func (self Int4bound) Excluded() int32 {
+	if self.tag != Int4boundExcluded {
+		panic("tag mismatch")
+	}
+	return self.value.(int32)
+}
+
+func MakeInt4boundIncluded(value int32) Int4bound {
+	return Int4bound{Int4boundIncluded, value}
+}
+func MakeInt4boundExcluded(value int32) Int4bound {
+	return Int4bound{Int4boundExcluded, value}
+}
+func MakeInt4boundUnbounded() Int4bound {
+	return Int4bound{Int4boundUnbounded, nil}
+}
+
+const (
+	Int8boundIncluded  uint8 = 0
+	Int8boundExcluded  uint8 = 1
+	Int8boundUnbounded uint8 = 2
+)
+
+type Int8bound struct {
+	tag   uint8
+	value any
+}
+
+func (self Int8bound) Tag() uint8 {
+	return self.tag
+}
+
+func (self Int8bound) Included() int64 {
+	if self.tag != Int8boundIncluded {
+		panic("tag mismatch")
+	}
+	return self.value.(int64)
+}
+func (self Int8bound) Excluded() int64 {
+	if self.tag != Int8boundExcluded {
+		panic("tag mismatch")
+	}
+	return self.value.(int64)
+}
+
+func MakeInt8boundIncluded(value int64) Int8bound {
+	return Int8bound{Int8boundIncluded, value}
+}
+func MakeInt8boundExcluded(value int64) Int8bound {
+	return Int8bound{Int8boundExcluded, value}
+}
+func MakeInt8boundUnbounded() Int8bound {
+	return Int8bound{Int8boundUnbounded, nil}
+}
+
+const (
+	NumboundIncluded  uint8 = 0
+	NumboundExcluded  uint8 = 1
+	NumboundUnbounded uint8 = 2
+)
+
+type Numbound struct {
+	tag   uint8
+	value any
+}
+
+func (self Numbound) Tag() uint8 {
+	return self.tag
+}
+
+func (self Numbound) Included() string {
+	if self.tag != NumboundIncluded {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Numbound) Excluded() string {
+	if self.tag != NumboundExcluded {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+
+func MakeNumboundIncluded(value string) Numbound {
+	return Numbound{NumboundIncluded, value}
+}
+func MakeNumboundExcluded(value string) Numbound {
+	return Numbound{NumboundExcluded, value}
+}
+func MakeNumboundUnbounded() Numbound {
+	return Numbound{NumboundUnbounded, nil}
+}
+
+const (
+	TsboundIncluded  uint8 = 0
+	TsboundExcluded  uint8 = 1
+	TsboundUnbounded uint8 = 2
+)
+
+type Tsbound struct {
+	tag   uint8
+	value any
+}
+
+func (self Tsbound) Tag() uint8 {
+	return self.tag
+}
+
+func (self Tsbound) Included() golem_rdbms_types.Timestamp {
+	if self.tag != TsboundIncluded {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Timestamp)
+}
+func (self Tsbound) Excluded() golem_rdbms_types.Timestamp {
+	if self.tag != TsboundExcluded {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Timestamp)
+}
+
+func MakeTsboundIncluded(value golem_rdbms_types.Timestamp) Tsbound {
+	return Tsbound{TsboundIncluded, value}
+}
+func MakeTsboundExcluded(value golem_rdbms_types.Timestamp) Tsbound {
+	return Tsbound{TsboundExcluded, value}
+}
+func MakeTsboundUnbounded() Tsbound {
+	return Tsbound{TsboundUnbounded, nil}
+}
+
+const (
+	TstzboundIncluded  uint8 = 0
+	TstzboundExcluded  uint8 = 1
+	TstzboundUnbounded uint8 = 2
+)
+
+type Tstzbound struct {
+	tag   uint8
+	value any
+}
+
+func (self Tstzbound) Tag() uint8 {
+	return self.tag
+}
+
+func (self Tstzbound) Included() golem_rdbms_types.Timestamptz {
+	if self.tag != TstzboundIncluded {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Timestamptz)
+}
+func (self Tstzbound) Excluded() golem_rdbms_types.Timestamptz {
+	if self.tag != TstzboundExcluded {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Timestamptz)
+}
+
+func MakeTstzboundIncluded(value golem_rdbms_types.Timestamptz) Tstzbound {
+	return Tstzbound{TstzboundIncluded, value}
+}
+func MakeTstzboundExcluded(value golem_rdbms_types.Timestamptz) Tstzbound {
+	return Tstzbound{TstzboundExcluded, value}
+}
+func MakeTstzboundUnbounded() Tstzbound {
+	return Tstzbound{TstzboundUnbounded, nil}
+}
+
+const (
+	DateboundIncluded  uint8 = 0
+	DateboundExcluded  uint8 = 1
+	DateboundUnbounded uint8 = 2
+)
+
+type Datebound struct {
+	tag   uint8
+	value any
+}
+
+func (self Datebound) Tag() uint8 {
+	return self.tag
+}
+
+func (self Datebound) Included() golem_rdbms_types.Date {
+	if self.tag != DateboundIncluded {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Date)
+}
+func (self Datebound) Excluded() golem_rdbms_types.Date {
+	if self.tag != DateboundExcluded {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Date)
+}
+
+func MakeDateboundIncluded(value golem_rdbms_types.Date) Datebound {
+	return Datebound{DateboundIncluded, value}
+}
+func MakeDateboundExcluded(value golem_rdbms_types.Date) Datebound {
+	return Datebound{DateboundExcluded, value}
+}
+func MakeDateboundUnbounded() Datebound {
+	return Datebound{DateboundUnbounded, nil}
+}
+
+type Int4range struct {
+	Start Int4bound
+	End   Int4bound
+}
+
+type Int8range struct {
+	Start Int8bound
+	End   Int8bound
+}
+
+type Numrange struct {
+	Start Numbound
+	End   Numbound
+}
+
+type Tsrange struct {
+	Start Tsbound
+	End   Tsbound
+}
+
+type Tstzrange struct {
+	Start Tstzbound
+	End   Tstzbound
+}
+
+type Daterange struct {
+	Start Datebound
+	End   Datebound
+}
+
+type EnumerationType struct {
+	Name string
+}
+
+type Enumeration struct {
+	Name  string
+	Value string
+}
+
+type SparseVec struct {
+	Dim     int32
+	Indices []int32
+	Values  []float32
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [resource-drop]lazy-db-value
+func resourceDropLazyDbValue(handle int32)
+
+type LazyDbValue struct {
+	handle *witRuntime.Handle
+}
+
+func (self *LazyDbValue) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *LazyDbValue) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *LazyDbValue) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *LazyDbValue) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropLazyDbValue(handle)
+	}
+}
+
+func LazyDbValueFromOwnHandle(handleValue int32) *LazyDbValue {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &LazyDbValue{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropLazyDbValue(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func LazyDbValueFromBorrowHandle(handleValue int32) *LazyDbValue {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &LazyDbValue{handle}
+}
+
+type Composite struct {
+	Name   string
+	Values []*LazyDbValue
+}
+
+type Domain struct {
+	Name  string
+	Value *LazyDbValue
+}
+
+const (
+	ValueBoundIncluded  uint8 = 0
+	ValueBoundExcluded  uint8 = 1
+	ValueBoundUnbounded uint8 = 2
+)
+
+type ValueBound struct {
+	tag   uint8
+	value any
+}
+
+func (self ValueBound) Tag() uint8 {
+	return self.tag
+}
+
+func (self ValueBound) Included() *LazyDbValue {
+	if self.tag != ValueBoundIncluded {
+		panic("tag mismatch")
+	}
+	return self.value.(*LazyDbValue)
+}
+func (self ValueBound) Excluded() *LazyDbValue {
+	if self.tag != ValueBoundExcluded {
+		panic("tag mismatch")
+	}
+	return self.value.(*LazyDbValue)
+}
+
+func MakeValueBoundIncluded(value *LazyDbValue) ValueBound {
+	return ValueBound{ValueBoundIncluded, value}
+}
+func MakeValueBoundExcluded(value *LazyDbValue) ValueBound {
+	return ValueBound{ValueBoundExcluded, value}
+}
+func MakeValueBoundUnbounded() ValueBound {
+	return ValueBound{ValueBoundUnbounded, nil}
+}
+
+type ValuesRange struct {
+	Start ValueBound
+	End   ValueBound
+}
+
+type Range struct {
+	Name  string
+	Value ValuesRange
+}
+
+const (
+	DbValueCharacter   uint8 = 0
+	DbValueInt2        uint8 = 1
+	DbValueInt4        uint8 = 2
+	DbValueInt8        uint8 = 3
+	DbValueFloat4      uint8 = 4
+	DbValueFloat8      uint8 = 5
+	DbValueNumeric     uint8 = 6
+	DbValueBoolean     uint8 = 7
+	DbValueText        uint8 = 8
+	DbValueVarchar     uint8 = 9
+	DbValueBpchar      uint8 = 10
+	DbValueTimestamp   uint8 = 11
+	DbValueTimestamptz uint8 = 12
+	DbValueDate        uint8 = 13
+	DbValueTime        uint8 = 14
+	DbValueTimetz      uint8 = 15
+	DbValueInterval    uint8 = 16
+	DbValueBytea       uint8 = 17
+	DbValueJson        uint8 = 18
+	DbValueJsonb       uint8 = 19
+	DbValueJsonpath    uint8 = 20
+	DbValueXml         uint8 = 21
+	DbValueUuid        uint8 = 22
+	DbValueInet        uint8 = 23
+	DbValueCidr        uint8 = 24
+	DbValueMacaddr     uint8 = 25
+	DbValueBit         uint8 = 26
+	DbValueVarbit      uint8 = 27
+	DbValueInt4range   uint8 = 28
+	DbValueInt8range   uint8 = 29
+	DbValueNumrange    uint8 = 30
+	DbValueTsrange     uint8 = 31
+	DbValueTstzrange   uint8 = 32
+	DbValueDaterange   uint8 = 33
+	DbValueMoney       uint8 = 34
+	DbValueOid         uint8 = 35
+	DbValueEnumeration uint8 = 36
+	DbValueComposite   uint8 = 37
+	DbValueDomain      uint8 = 38
+	DbValueArray       uint8 = 39
+	DbValueRange       uint8 = 40
+	DbValueNull        uint8 = 41
+	DbValueVector      uint8 = 42
+	DbValueHalfvec     uint8 = 43
+	DbValueSparsevec   uint8 = 44
+)
+
+type DbValue struct {
+	tag   uint8
+	value any
+}
+
+func (self DbValue) Tag() uint8 {
+	return self.tag
+}
+
+func (self DbValue) Character() int8 {
+	if self.tag != DbValueCharacter {
+		panic("tag mismatch")
+	}
+	return self.value.(int8)
+}
+func (self DbValue) Int2() int16 {
+	if self.tag != DbValueInt2 {
+		panic("tag mismatch")
+	}
+	return self.value.(int16)
+}
+func (self DbValue) Int4() int32 {
+	if self.tag != DbValueInt4 {
+		panic("tag mismatch")
+	}
+	return self.value.(int32)
+}
+func (self DbValue) Int8() int64 {
+	if self.tag != DbValueInt8 {
+		panic("tag mismatch")
+	}
+	return self.value.(int64)
+}
+func (self DbValue) Float4() float32 {
+	if self.tag != DbValueFloat4 {
+		panic("tag mismatch")
+	}
+	return self.value.(float32)
+}
+func (self DbValue) Float8() float64 {
+	if self.tag != DbValueFloat8 {
+		panic("tag mismatch")
+	}
+	return self.value.(float64)
+}
+func (self DbValue) Numeric() string {
+	if self.tag != DbValueNumeric {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Boolean() bool {
+	if self.tag != DbValueBoolean {
+		panic("tag mismatch")
+	}
+	return self.value.(bool)
+}
+func (self DbValue) Text() string {
+	if self.tag != DbValueText {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Varchar() string {
+	if self.tag != DbValueVarchar {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Bpchar() string {
+	if self.tag != DbValueBpchar {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Timestamp() golem_rdbms_types.Timestamp {
+	if self.tag != DbValueTimestamp {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Timestamp)
+}
+func (self DbValue) Timestamptz() golem_rdbms_types.Timestamptz {
+	if self.tag != DbValueTimestamptz {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Timestamptz)
+}
+func (self DbValue) Date() golem_rdbms_types.Date {
+	if self.tag != DbValueDate {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Date)
+}
+func (self DbValue) Time() golem_rdbms_types.Time {
+	if self.tag != DbValueTime {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Time)
+}
+func (self DbValue) Timetz() golem_rdbms_types.Timetz {
+	if self.tag != DbValueTimetz {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Timetz)
+}
+func (self DbValue) Interval() Interval {
+	if self.tag != DbValueInterval {
+		panic("tag mismatch")
+	}
+	return self.value.(Interval)
+}
+func (self DbValue) Bytea() []uint8 {
+	if self.tag != DbValueBytea {
+		panic("tag mismatch")
+	}
+	return self.value.([]uint8)
+}
+func (self DbValue) Json() string {
+	if self.tag != DbValueJson {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Jsonb() string {
+	if self.tag != DbValueJsonb {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Jsonpath() string {
+	if self.tag != DbValueJsonpath {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Xml() string {
+	if self.tag != DbValueXml {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self DbValue) Uuid() golem_rdbms_types.Uuid {
+	if self.tag != DbValueUuid {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.Uuid)
+}
+func (self DbValue) Inet() golem_rdbms_types.IpAddress {
+	if self.tag != DbValueInet {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.IpAddress)
+}
+func (self DbValue) Cidr() golem_rdbms_types.IpAddress {
+	if self.tag != DbValueCidr {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.IpAddress)
+}
+func (self DbValue) Macaddr() golem_rdbms_types.MacAddress {
+	if self.tag != DbValueMacaddr {
+		panic("tag mismatch")
+	}
+	return self.value.(golem_rdbms_types.MacAddress)
+}
+func (self DbValue) Bit() []bool {
+	if self.tag != DbValueBit {
+		panic("tag mismatch")
+	}
+	return self.value.([]bool)
+}
+func (self DbValue) Varbit() []bool {
+	if self.tag != DbValueVarbit {
+		panic("tag mismatch")
+	}
+	return self.value.([]bool)
+}
+func (self DbValue) Int4range() Int4range {
+	if self.tag != DbValueInt4range {
+		panic("tag mismatch")
+	}
+	return self.value.(Int4range)
+}
+func (self DbValue) Int8range() Int8range {
+	if self.tag != DbValueInt8range {
+		panic("tag mismatch")
+	}
+	return self.value.(Int8range)
+}
+func (self DbValue) Numrange() Numrange {
+	if self.tag != DbValueNumrange {
+		panic("tag mismatch")
+	}
+	return self.value.(Numrange)
+}
+func (self DbValue) Tsrange() Tsrange {
+	if self.tag != DbValueTsrange {
+		panic("tag mismatch")
+	}
+	return self.value.(Tsrange)
+}
+func (self DbValue) Tstzrange() Tstzrange {
+	if self.tag != DbValueTstzrange {
+		panic("tag mismatch")
+	}
+	return self.value.(Tstzrange)
+}
+func (self DbValue) Daterange() Daterange {
+	if self.tag != DbValueDaterange {
+		panic("tag mismatch")
+	}
+	return self.value.(Daterange)
+}
+func (self DbValue) Money() int64 {
+	if self.tag != DbValueMoney {
+		panic("tag mismatch")
+	}
+	return self.value.(int64)
+}
+func (self DbValue) Oid() uint32 {
+	if self.tag != DbValueOid {
+		panic("tag mismatch")
+	}
+	return self.value.(uint32)
+}
+func (self DbValue) Enumeration() Enumeration {
+	if self.tag != DbValueEnumeration {
+		panic("tag mismatch")
+	}
+	return self.value.(Enumeration)
+}
+func (self DbValue) Composite() Composite {
+	if self.tag != DbValueComposite {
+		panic("tag mismatch")
+	}
+	return self.value.(Composite)
+}
+func (self DbValue) Domain() Domain {
+	if self.tag != DbValueDomain {
+		panic("tag mismatch")
+	}
+	return self.value.(Domain)
+}
+func (self DbValue) Array() []*LazyDbValue {
+	if self.tag != DbValueArray {
+		panic("tag mismatch")
+	}
+	return self.value.([]*LazyDbValue)
+}
+func (self DbValue) Range() Range {
+	if self.tag != DbValueRange {
+		panic("tag mismatch")
+	}
+	return self.value.(Range)
+}
+func (self DbValue) Vector() []float32 {
+	if self.tag != DbValueVector {
+		panic("tag mismatch")
+	}
+	return self.value.([]float32)
+}
+func (self DbValue) Halfvec() []float32 {
+	if self.tag != DbValueHalfvec {
+		panic("tag mismatch")
+	}
+	return self.value.([]float32)
+}
+func (self DbValue) Sparsevec() SparseVec {
+	if self.tag != DbValueSparsevec {
+		panic("tag mismatch")
+	}
+	return self.value.(SparseVec)
+}
+
+func MakeDbValueCharacter(value int8) DbValue {
+	return DbValue{DbValueCharacter, value}
+}
+func MakeDbValueInt2(value int16) DbValue {
+	return DbValue{DbValueInt2, value}
+}
+func MakeDbValueInt4(value int32) DbValue {
+	return DbValue{DbValueInt4, value}
+}
+func MakeDbValueInt8(value int64) DbValue {
+	return DbValue{DbValueInt8, value}
+}
+func MakeDbValueFloat4(value float32) DbValue {
+	return DbValue{DbValueFloat4, value}
+}
+func MakeDbValueFloat8(value float64) DbValue {
+	return DbValue{DbValueFloat8, value}
+}
+func MakeDbValueNumeric(value string) DbValue {
+	return DbValue{DbValueNumeric, value}
+}
+func MakeDbValueBoolean(value bool) DbValue {
+	return DbValue{DbValueBoolean, value}
+}
+func MakeDbValueText(value string) DbValue {
+	return DbValue{DbValueText, value}
+}
+func MakeDbValueVarchar(value string) DbValue {
+	return DbValue{DbValueVarchar, value}
+}
+func MakeDbValueBpchar(value string) DbValue {
+	return DbValue{DbValueBpchar, value}
+}
+func MakeDbValueTimestamp(value golem_rdbms_types.Timestamp) DbValue {
+	return DbValue{DbValueTimestamp, value}
+}
+func MakeDbValueTimestamptz(value golem_rdbms_types.Timestamptz) DbValue {
+	return DbValue{DbValueTimestamptz, value}
+}
+func MakeDbValueDate(value golem_rdbms_types.Date) DbValue {
+	return DbValue{DbValueDate, value}
+}
+func MakeDbValueTime(value golem_rdbms_types.Time) DbValue {
+	return DbValue{DbValueTime, value}
+}
+func MakeDbValueTimetz(value golem_rdbms_types.Timetz) DbValue {
+	return DbValue{DbValueTimetz, value}
+}
+func MakeDbValueInterval(value Interval) DbValue {
+	return DbValue{DbValueInterval, value}
+}
+func MakeDbValueBytea(value []uint8) DbValue {
+	return DbValue{DbValueBytea, value}
+}
+func MakeDbValueJson(value string) DbValue {
+	return DbValue{DbValueJson, value}
+}
+func MakeDbValueJsonb(value string) DbValue {
+	return DbValue{DbValueJsonb, value}
+}
+func MakeDbValueJsonpath(value string) DbValue {
+	return DbValue{DbValueJsonpath, value}
+}
+func MakeDbValueXml(value string) DbValue {
+	return DbValue{DbValueXml, value}
+}
+func MakeDbValueUuid(value golem_rdbms_types.Uuid) DbValue {
+	return DbValue{DbValueUuid, value}
+}
+func MakeDbValueInet(value golem_rdbms_types.IpAddress) DbValue {
+	return DbValue{DbValueInet, value}
+}
+func MakeDbValueCidr(value golem_rdbms_types.IpAddress) DbValue {
+	return DbValue{DbValueCidr, value}
+}
+func MakeDbValueMacaddr(value golem_rdbms_types.MacAddress) DbValue {
+	return DbValue{DbValueMacaddr, value}
+}
+func MakeDbValueBit(value []bool) DbValue {
+	return DbValue{DbValueBit, value}
+}
+func MakeDbValueVarbit(value []bool) DbValue {
+	return DbValue{DbValueVarbit, value}
+}
+func MakeDbValueInt4range(value Int4range) DbValue {
+	return DbValue{DbValueInt4range, value}
+}
+func MakeDbValueInt8range(value Int8range) DbValue {
+	return DbValue{DbValueInt8range, value}
+}
+func MakeDbValueNumrange(value Numrange) DbValue {
+	return DbValue{DbValueNumrange, value}
+}
+func MakeDbValueTsrange(value Tsrange) DbValue {
+	return DbValue{DbValueTsrange, value}
+}
+func MakeDbValueTstzrange(value Tstzrange) DbValue {
+	return DbValue{DbValueTstzrange, value}
+}
+func MakeDbValueDaterange(value Daterange) DbValue {
+	return DbValue{DbValueDaterange, value}
+}
+func MakeDbValueMoney(value int64) DbValue {
+	return DbValue{DbValueMoney, value}
+}
+func MakeDbValueOid(value uint32) DbValue {
+	return DbValue{DbValueOid, value}
+}
+func MakeDbValueEnumeration(value Enumeration) DbValue {
+	return DbValue{DbValueEnumeration, value}
+}
+func MakeDbValueComposite(value Composite) DbValue {
+	return DbValue{DbValueComposite, value}
+}
+func MakeDbValueDomain(value Domain) DbValue {
+	return DbValue{DbValueDomain, value}
+}
+func MakeDbValueArray(value []*LazyDbValue) DbValue {
+	return DbValue{DbValueArray, value}
+}
+func MakeDbValueRange(value Range) DbValue {
+	return DbValue{DbValueRange, value}
+}
+func MakeDbValueNull() DbValue {
+	return DbValue{DbValueNull, nil}
+}
+func MakeDbValueVector(value []float32) DbValue {
+	return DbValue{DbValueVector, value}
+}
+func MakeDbValueHalfvec(value []float32) DbValue {
+	return DbValue{DbValueHalfvec, value}
+}
+func MakeDbValueSparsevec(value SparseVec) DbValue {
+	return DbValue{DbValueSparsevec, value}
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [resource-drop]lazy-db-column-type
+func resourceDropLazyDbColumnType(handle int32)
+
+type LazyDbColumnType struct {
+	handle *witRuntime.Handle
+}
+
+func (self *LazyDbColumnType) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *LazyDbColumnType) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *LazyDbColumnType) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *LazyDbColumnType) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropLazyDbColumnType(handle)
+	}
+}
+
+func LazyDbColumnTypeFromOwnHandle(handleValue int32) *LazyDbColumnType {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &LazyDbColumnType{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropLazyDbColumnType(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func LazyDbColumnTypeFromBorrowHandle(handleValue int32) *LazyDbColumnType {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &LazyDbColumnType{handle}
+}
+
+type CompositeType struct {
+	Name       string
+	Attributes []witTypes.Tuple2[string, *LazyDbColumnType]
+}
+
+type DomainType struct {
+	Name     string
+	BaseType *LazyDbColumnType
+}
+
+type RangeType struct {
+	Name     string
+	BaseType *LazyDbColumnType
+}
+
+const (
+	DbColumnTypeCharacter   uint8 = 0
+	DbColumnTypeInt2        uint8 = 1
+	DbColumnTypeInt4        uint8 = 2
+	DbColumnTypeInt8        uint8 = 3
+	DbColumnTypeFloat4      uint8 = 4
+	DbColumnTypeFloat8      uint8 = 5
+	DbColumnTypeNumeric     uint8 = 6
+	DbColumnTypeBoolean     uint8 = 7
+	DbColumnTypeText        uint8 = 8
+	DbColumnTypeVarchar     uint8 = 9
+	DbColumnTypeBpchar      uint8 = 10
+	DbColumnTypeTimestamp   uint8 = 11
+	DbColumnTypeTimestamptz uint8 = 12
+	DbColumnTypeDate        uint8 = 13
+	DbColumnTypeTime        uint8 = 14
+	DbColumnTypeTimetz      uint8 = 15
+	DbColumnTypeInterval    uint8 = 16
+	DbColumnTypeBytea       uint8 = 17
+	DbColumnTypeUuid        uint8 = 18
+	DbColumnTypeXml         uint8 = 19
+	DbColumnTypeJson        uint8 = 20
+	DbColumnTypeJsonb       uint8 = 21
+	DbColumnTypeJsonpath    uint8 = 22
+	DbColumnTypeInet        uint8 = 23
+	DbColumnTypeCidr        uint8 = 24
+	DbColumnTypeMacaddr     uint8 = 25
+	DbColumnTypeBit         uint8 = 26
+	DbColumnTypeVarbit      uint8 = 27
+	DbColumnTypeInt4range   uint8 = 28
+	DbColumnTypeInt8range   uint8 = 29
+	DbColumnTypeNumrange    uint8 = 30
+	DbColumnTypeTsrange     uint8 = 31
+	DbColumnTypeTstzrange   uint8 = 32
+	DbColumnTypeDaterange   uint8 = 33
+	DbColumnTypeMoney       uint8 = 34
+	DbColumnTypeOid         uint8 = 35
+	DbColumnTypeEnumeration uint8 = 36
+	DbColumnTypeComposite   uint8 = 37
+	DbColumnTypeDomain      uint8 = 38
+	DbColumnTypeArray       uint8 = 39
+	DbColumnTypeRange       uint8 = 40
+	DbColumnTypeVector      uint8 = 41
+	DbColumnTypeHalfvec     uint8 = 42
+	DbColumnTypeSparsevec   uint8 = 43
+)
+
+type DbColumnType struct {
+	tag   uint8
+	value any
+}
+
+func (self DbColumnType) Tag() uint8 {
+	return self.tag
+}
+
+func (self DbColumnType) Enumeration() EnumerationType {
+	if self.tag != DbColumnTypeEnumeration {
+		panic("tag mismatch")
+	}
+	return self.value.(EnumerationType)
+}
+func (self DbColumnType) Composite() CompositeType {
+	if self.tag != DbColumnTypeComposite {
+		panic("tag mismatch")
+	}
+	return self.value.(CompositeType)
+}
+func (self DbColumnType) Domain() DomainType {
+	if self.tag != DbColumnTypeDomain {
+		panic("tag mismatch")
+	}
+	return self.value.(DomainType)
+}
+func (self DbColumnType) Array() *LazyDbColumnType {
+	if self.tag != DbColumnTypeArray {
+		panic("tag mismatch")
+	}
+	return self.value.(*LazyDbColumnType)
+}
+func (self DbColumnType) Range() RangeType {
+	if self.tag != DbColumnTypeRange {
+		panic("tag mismatch")
+	}
+	return self.value.(RangeType)
+}
+
+func MakeDbColumnTypeCharacter() DbColumnType {
+	return DbColumnType{DbColumnTypeCharacter, nil}
+}
+func MakeDbColumnTypeInt2() DbColumnType {
+	return DbColumnType{DbColumnTypeInt2, nil}
+}
+func MakeDbColumnTypeInt4() DbColumnType {
+	return DbColumnType{DbColumnTypeInt4, nil}
+}
+func MakeDbColumnTypeInt8() DbColumnType {
+	return DbColumnType{DbColumnTypeInt8, nil}
+}
+func MakeDbColumnTypeFloat4() DbColumnType {
+	return DbColumnType{DbColumnTypeFloat4, nil}
+}
+func MakeDbColumnTypeFloat8() DbColumnType {
+	return DbColumnType{DbColumnTypeFloat8, nil}
+}
+func MakeDbColumnTypeNumeric() DbColumnType {
+	return DbColumnType{DbColumnTypeNumeric, nil}
+}
+func MakeDbColumnTypeBoolean() DbColumnType {
+	return DbColumnType{DbColumnTypeBoolean, nil}
+}
+func MakeDbColumnTypeText() DbColumnType {
+	return DbColumnType{DbColumnTypeText, nil}
+}
+func MakeDbColumnTypeVarchar() DbColumnType {
+	return DbColumnType{DbColumnTypeVarchar, nil}
+}
+func MakeDbColumnTypeBpchar() DbColumnType {
+	return DbColumnType{DbColumnTypeBpchar, nil}
+}
+func MakeDbColumnTypeTimestamp() DbColumnType {
+	return DbColumnType{DbColumnTypeTimestamp, nil}
+}
+func MakeDbColumnTypeTimestamptz() DbColumnType {
+	return DbColumnType{DbColumnTypeTimestamptz, nil}
+}
+func MakeDbColumnTypeDate() DbColumnType {
+	return DbColumnType{DbColumnTypeDate, nil}
+}
+func MakeDbColumnTypeTime() DbColumnType {
+	return DbColumnType{DbColumnTypeTime, nil}
+}
+func MakeDbColumnTypeTimetz() DbColumnType {
+	return DbColumnType{DbColumnTypeTimetz, nil}
+}
+func MakeDbColumnTypeInterval() DbColumnType {
+	return DbColumnType{DbColumnTypeInterval, nil}
+}
+func MakeDbColumnTypeBytea() DbColumnType {
+	return DbColumnType{DbColumnTypeBytea, nil}
+}
+func MakeDbColumnTypeUuid() DbColumnType {
+	return DbColumnType{DbColumnTypeUuid, nil}
+}
+func MakeDbColumnTypeXml() DbColumnType {
+	return DbColumnType{DbColumnTypeXml, nil}
+}
+func MakeDbColumnTypeJson() DbColumnType {
+	return DbColumnType{DbColumnTypeJson, nil}
+}
+func MakeDbColumnTypeJsonb() DbColumnType {
+	return DbColumnType{DbColumnTypeJsonb, nil}
+}
+func MakeDbColumnTypeJsonpath() DbColumnType {
+	return DbColumnType{DbColumnTypeJsonpath, nil}
+}
+func MakeDbColumnTypeInet() DbColumnType {
+	return DbColumnType{DbColumnTypeInet, nil}
+}
+func MakeDbColumnTypeCidr() DbColumnType {
+	return DbColumnType{DbColumnTypeCidr, nil}
+}
+func MakeDbColumnTypeMacaddr() DbColumnType {
+	return DbColumnType{DbColumnTypeMacaddr, nil}
+}
+func MakeDbColumnTypeBit() DbColumnType {
+	return DbColumnType{DbColumnTypeBit, nil}
+}
+func MakeDbColumnTypeVarbit() DbColumnType {
+	return DbColumnType{DbColumnTypeVarbit, nil}
+}
+func MakeDbColumnTypeInt4range() DbColumnType {
+	return DbColumnType{DbColumnTypeInt4range, nil}
+}
+func MakeDbColumnTypeInt8range() DbColumnType {
+	return DbColumnType{DbColumnTypeInt8range, nil}
+}
+func MakeDbColumnTypeNumrange() DbColumnType {
+	return DbColumnType{DbColumnTypeNumrange, nil}
+}
+func MakeDbColumnTypeTsrange() DbColumnType {
+	return DbColumnType{DbColumnTypeTsrange, nil}
+}
+func MakeDbColumnTypeTstzrange() DbColumnType {
+	return DbColumnType{DbColumnTypeTstzrange, nil}
+}
+func MakeDbColumnTypeDaterange() DbColumnType {
+	return DbColumnType{DbColumnTypeDaterange, nil}
+}
+func MakeDbColumnTypeMoney() DbColumnType {
+	return DbColumnType{DbColumnTypeMoney, nil}
+}
+func MakeDbColumnTypeOid() DbColumnType {
+	return DbColumnType{DbColumnTypeOid, nil}
+}
+func MakeDbColumnTypeEnumeration(value EnumerationType) DbColumnType {
+	return DbColumnType{DbColumnTypeEnumeration, value}
+}
+func MakeDbColumnTypeComposite(value CompositeType) DbColumnType {
+	return DbColumnType{DbColumnTypeComposite, value}
+}
+func MakeDbColumnTypeDomain(value DomainType) DbColumnType {
+	return DbColumnType{DbColumnTypeDomain, value}
+}
+func MakeDbColumnTypeArray(value *LazyDbColumnType) DbColumnType {
+	return DbColumnType{DbColumnTypeArray, value}
+}
+func MakeDbColumnTypeRange(value RangeType) DbColumnType {
+	return DbColumnType{DbColumnTypeRange, value}
+}
+func MakeDbColumnTypeVector() DbColumnType {
+	return DbColumnType{DbColumnTypeVector, nil}
+}
+func MakeDbColumnTypeHalfvec() DbColumnType {
+	return DbColumnType{DbColumnTypeHalfvec, nil}
+}
+func MakeDbColumnTypeSparsevec() DbColumnType {
+	return DbColumnType{DbColumnTypeSparsevec, nil}
+}
+
+type DbColumn struct {
+	Ordinal    uint64
+	Name       string
+	DbType     DbColumnType
+	DbTypeName string
+}
+
+// A single row of values
+type DbRow struct {
+	Values []DbValue
+}
+
+type DbResult struct {
+	Columns []DbColumn
+	Rows    []DbRow
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [resource-drop]db-result-stream
+func resourceDropDbResultStream(handle int32)
+
+// A potentially very large and lazy stream of rows:
+type DbResultStream struct {
+	handle *witRuntime.Handle
+}
+
+func (self *DbResultStream) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *DbResultStream) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *DbResultStream) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *DbResultStream) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropDbResultStream(handle)
+	}
+}
+
+func DbResultStreamFromOwnHandle(handleValue int32) *DbResultStream {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &DbResultStream{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropDbResultStream(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func DbResultStreamFromBorrowHandle(handleValue int32) *DbResultStream {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &DbResultStream{handle}
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [resource-drop]db-connection
+func resourceDropDbConnection(handle int32)
+
+type DbConnection struct {
+	handle *witRuntime.Handle
+}
+
+func (self *DbConnection) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *DbConnection) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *DbConnection) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *DbConnection) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropDbConnection(handle)
+	}
+}
+
+func DbConnectionFromOwnHandle(handleValue int32) *DbConnection {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &DbConnection{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropDbConnection(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func DbConnectionFromBorrowHandle(handleValue int32) *DbConnection {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &DbConnection{handle}
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [resource-drop]db-transaction
+func resourceDropDbTransaction(handle int32)
+
+type DbTransaction struct {
+	handle *witRuntime.Handle
+}
+
+func (self *DbTransaction) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *DbTransaction) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *DbTransaction) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *DbTransaction) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropDbTransaction(handle)
+	}
+}
+
+func DbTransactionFromOwnHandle(handleValue int32) *DbTransaction {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &DbTransaction{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropDbTransaction(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func DbTransactionFromBorrowHandle(handleValue int32) *DbTransaction {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &DbTransaction{handle}
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [constructor]lazy-db-value
+func wasm_import_constructor_lazy_db_value(arg0 uintptr) int32
+
+func MakeLazyDbValue(value DbValue) *LazyDbValue {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 56, 8))
+
+	switch value.Tag() {
+	case DbValueCharacter:
+		payload := value.Character()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(0))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(payload))
+
+	case DbValueInt2:
+		payload := value.Int2()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(1))
+		*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int16(int32(payload))
+
+	case DbValueInt4:
+		payload := value.Int4()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(2))
+		*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = payload
+
+	case DbValueInt8:
+		payload := value.Int8()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(3))
+		*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = payload
+
+	case DbValueFloat4:
+		payload := value.Float4()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(4))
+		*(*float32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = payload
+
+	case DbValueFloat8:
+		payload := value.Float8()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(5))
+		*(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = payload
+
+	case DbValueNumeric:
+		payload := value.Numeric()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(6))
+		utf8 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf8)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uint32(len(payload)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(utf8)))
+
+	case DbValueBoolean:
+		payload := value.Boolean()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(7))
+		var result int32
+		if payload {
+			result = 1
+		} else {
+			result = 0
+		}
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(result)
+
+	case DbValueText:
+		payload := value.Text()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(8))
+		utf80 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf80)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uint32(len(payload)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(utf80)))
+
+	case DbValueVarchar:
+		payload := value.Varchar()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(9))
+		utf81 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf81)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uint32(len(payload)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(utf81)))
+
+	case DbValueBpchar:
+		payload := value.Bpchar()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(10))
+		utf82 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf82)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uint32(len(payload)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(utf82)))
+
+	case DbValueTimestamp:
+		payload := value.Timestamp()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(11))
+		*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = ((payload).Date).Year
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = int8(int32(((payload).Date).Month))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 13)) = int8(int32(((payload).Date).Day))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = int8(int32(((payload).Time).Hour))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 17)) = int8(int32(((payload).Time).Minute))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 18)) = int8(int32(((payload).Time).Second))
+		*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 20)) = int32(((payload).Time).Nanosecond)
+
+	case DbValueTimestamptz:
+		payload := value.Timestamptz()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(12))
+		*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = (((payload).Timestamp).Date).Year
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = int8(int32((((payload).Timestamp).Date).Month))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 13)) = int8(int32((((payload).Timestamp).Date).Day))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = int8(int32((((payload).Timestamp).Time).Hour))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 17)) = int8(int32((((payload).Timestamp).Time).Minute))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 18)) = int8(int32((((payload).Timestamp).Time).Second))
+		*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 20)) = int32((((payload).Timestamp).Time).Nanosecond)
+		*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 24)) = (payload).Offset
+
+	case DbValueDate:
+		payload := value.Date()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(13))
+		*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = (payload).Year
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = int8(int32((payload).Month))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 13)) = int8(int32((payload).Day))
+
+	case DbValueTime:
+		payload := value.Time()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(14))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32((payload).Hour))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 9)) = int8(int32((payload).Minute))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 10)) = int8(int32((payload).Second))
+		*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = int32((payload).Nanosecond)
+
+	case DbValueTimetz:
+		payload := value.Timetz()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(15))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(((payload).Time).Hour))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 9)) = int8(int32(((payload).Time).Minute))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 10)) = int8(int32(((payload).Time).Second))
+		*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = int32(((payload).Time).Nanosecond)
+		*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = (payload).Offset
+
+	case DbValueInterval:
+		payload := value.Interval()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(16))
+		*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = (payload).Months
+		*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = (payload).Days
+		*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = (payload).Microseconds
+
+	case DbValueBytea:
+		payload := value.Bytea()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(17))
+		data := unsafe.Pointer(unsafe.SliceData(payload))
+		pinner.Pin(data)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uint32(len(payload)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(data)))
+
+	case DbValueJson:
+		payload := value.Json()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(18))
+		utf83 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf83)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uint32(len(payload)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(utf83)))
+
+	case DbValueJsonb:
+		payload := value.Jsonb()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(19))
+		utf84 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf84)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uint32(len(payload)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(utf84)))
+
+	case DbValueJsonpath:
+		payload := value.Jsonpath()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(20))
+		utf85 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf85)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uint32(len(payload)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(utf85)))
+
+	case DbValueXml:
+		payload := value.Xml()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(21))
+		utf86 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf86)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uint32(len(payload)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(utf86)))
+
+	case DbValueUuid:
+		payload := value.Uuid()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(22))
+		*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int64((payload).HighBits)
+		*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = int64((payload).LowBits)
+
+	case DbValueInet:
+		payload := value.Inet()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(23))
+
+		switch payload.Tag() {
+		case golem_rdbms_types.IpAddressIpv4:
+			payload := payload.Ipv4()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 10)) = int8(int32((payload).F0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 11)) = int8(int32((payload).F1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = int8(int32((payload).F2))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 13)) = int8(int32((payload).F3))
+
+		case golem_rdbms_types.IpAddressIpv6:
+			payload := payload.Ipv6()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(1))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 10)) = int16(int32((payload).F0))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = int16(int32((payload).F1))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 14)) = int16(int32((payload).F2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = int16(int32((payload).F3))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 18)) = int16(int32((payload).F4))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 20)) = int16(int32((payload).F5))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 22)) = int16(int32((payload).F6))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 24)) = int16(int32((payload).F7))
+
+		default:
+			panic("unreachable")
+		}
+
+	case DbValueCidr:
+		payload := value.Cidr()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(24))
+
+		switch payload.Tag() {
+		case golem_rdbms_types.IpAddressIpv4:
+			payload := payload.Ipv4()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 10)) = int8(int32((payload).F0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 11)) = int8(int32((payload).F1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = int8(int32((payload).F2))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 13)) = int8(int32((payload).F3))
+
+		case golem_rdbms_types.IpAddressIpv6:
+			payload := payload.Ipv6()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(1))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 10)) = int16(int32((payload).F0))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = int16(int32((payload).F1))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 14)) = int16(int32((payload).F2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = int16(int32((payload).F3))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 18)) = int16(int32((payload).F4))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 20)) = int16(int32((payload).F5))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 22)) = int16(int32((payload).F6))
+			*(*int16)(unsafe.Add(unsafe.Pointer(returnArea), 24)) = int16(int32((payload).F7))
+
+		default:
+			panic("unreachable")
+		}
+
+	case DbValueMacaddr:
+		payload := value.Macaddr()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(25))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(((payload).Octets).F0))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 9)) = int8(int32(((payload).Octets).F1))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 10)) = int8(int32(((payload).Octets).F2))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 11)) = int8(int32(((payload).Octets).F3))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = int8(int32(((payload).Octets).F4))
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 13)) = int8(int32(((payload).Octets).F5))
+
+	case DbValueBit:
+		payload := value.Bit()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(26))
+		slice := payload
+		length := uint32(len(slice))
+		result8 := witRuntime.Allocate(pinner, uintptr(length*1), 1)
+		for index, element := range slice {
+			base := unsafe.Add(result8, index*1)
+			var result7 int32
+			if element {
+				result7 = 1
+			} else {
+				result7 = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result7)
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(length)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(result8)))
+
+	case DbValueVarbit:
+		payload := value.Varbit()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(27))
+		slice10 := payload
+		length12 := uint32(len(slice10))
+		result11 := witRuntime.Allocate(pinner, uintptr(length12*1), 1)
+		for index, element := range slice10 {
+			base := unsafe.Add(result11, index*1)
+			var result9 int32
+			if element {
+				result9 = 1
+			} else {
+				result9 = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result9)
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(length12)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(result11)))
+
+	case DbValueInt4range:
+		payload := value.Int4range()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(28))
+
+		switch (payload).Start.Tag() {
+		case Int4boundIncluded:
+			payload := (payload).Start.Included()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(0))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = payload
+
+		case Int4boundExcluded:
+			payload := (payload).Start.Excluded()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(1))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = payload
+
+		case Int4boundUnbounded:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(2))
+
+		default:
+			panic("unreachable")
+		}
+
+		switch (payload).End.Tag() {
+		case Int4boundIncluded:
+			payload := (payload).End.Included()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = int8(int32(0))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 20)) = payload
+
+		case Int4boundExcluded:
+			payload := (payload).End.Excluded()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = int8(int32(1))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 20)) = payload
+
+		case Int4boundUnbounded:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = int8(int32(2))
+
+		default:
+			panic("unreachable")
+		}
+
+	case DbValueInt8range:
+		payload := value.Int8range()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(29))
+
+		switch (payload).Start.Tag() {
+		case Int8boundIncluded:
+			payload := (payload).Start.Included()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(0))
+			*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = payload
+
+		case Int8boundExcluded:
+			payload := (payload).Start.Excluded()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(1))
+			*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = payload
+
+		case Int8boundUnbounded:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(2))
+
+		default:
+			panic("unreachable")
+		}
+
+		switch (payload).End.Tag() {
+		case Int8boundIncluded:
+			payload := (payload).End.Included()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 24)) = int8(int32(0))
+			*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 32)) = payload
+
+		case Int8boundExcluded:
+			payload := (payload).End.Excluded()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 24)) = int8(int32(1))
+			*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 32)) = payload
+
+		case Int8boundUnbounded:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 24)) = int8(int32(2))
+
+		default:
+			panic("unreachable")
+		}
+
+	case DbValueNumrange:
+		payload := value.Numrange()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(30))
+
+		switch (payload).Start.Tag() {
+		case NumboundIncluded:
+			payload := (payload).Start.Included()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(0))
+			utf813 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf813)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uintptr(uintptr(utf813)))
+
+		case NumboundExcluded:
+			payload := (payload).Start.Excluded()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(1))
+			utf814 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf814)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uintptr(uintptr(utf814)))
+
+		case NumboundUnbounded:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(2))
+
+		default:
+			panic("unreachable")
+		}
+
+		switch (payload).End.Tag() {
+		case NumboundIncluded:
+			payload := (payload).End.Included()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4))) = int8(int32(0))
+			utf815 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf815)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 5*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 4*4))) = uint32(uintptr(uintptr(utf815)))
+
+		case NumboundExcluded:
+			payload := (payload).End.Excluded()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4))) = int8(int32(1))
+			utf816 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf816)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 5*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 4*4))) = uint32(uintptr(uintptr(utf816)))
+
+		case NumboundUnbounded:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4))) = int8(int32(2))
+
+		default:
+			panic("unreachable")
+		}
+
+	case DbValueTsrange:
+		payload := value.Tsrange()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(31))
+
+		switch (payload).Start.Tag() {
+		case TsboundIncluded:
+			payload := (payload).Start.Included()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(0))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 17)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 20)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 21)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 22)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 24)) = int32(((payload).Time).Nanosecond)
+
+		case TsboundExcluded:
+			payload := (payload).Start.Excluded()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(1))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 17)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 20)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 21)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 22)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 24)) = int32(((payload).Time).Nanosecond)
+
+		case TsboundUnbounded:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(2))
+
+		default:
+			panic("unreachable")
+		}
+
+		switch (payload).End.Tag() {
+		case TsboundIncluded:
+			payload := (payload).End.Included()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 28)) = int8(int32(0))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 32)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 36)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 37)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 40)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 41)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 42)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 44)) = int32(((payload).Time).Nanosecond)
+
+		case TsboundExcluded:
+			payload := (payload).End.Excluded()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 28)) = int8(int32(1))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 32)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 36)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 37)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 40)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 41)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 42)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 44)) = int32(((payload).Time).Nanosecond)
+
+		case TsboundUnbounded:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 28)) = int8(int32(2))
+
+		default:
+			panic("unreachable")
+		}
+
+	case DbValueTstzrange:
+		payload := value.Tstzrange()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(32))
+
+		switch (payload).Start.Tag() {
+		case TstzboundIncluded:
+			payload := (payload).Start.Included()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(0))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = (((payload).Timestamp).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = int8(int32((((payload).Timestamp).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 17)) = int8(int32((((payload).Timestamp).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 20)) = int8(int32((((payload).Timestamp).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 21)) = int8(int32((((payload).Timestamp).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 22)) = int8(int32((((payload).Timestamp).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 24)) = int32((((payload).Timestamp).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 28)) = (payload).Offset
+
+		case TstzboundExcluded:
+			payload := (payload).Start.Excluded()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(1))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = (((payload).Timestamp).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = int8(int32((((payload).Timestamp).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 17)) = int8(int32((((payload).Timestamp).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 20)) = int8(int32((((payload).Timestamp).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 21)) = int8(int32((((payload).Timestamp).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 22)) = int8(int32((((payload).Timestamp).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 24)) = int32((((payload).Timestamp).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 28)) = (payload).Offset
+
+		case TstzboundUnbounded:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(2))
+
+		default:
+			panic("unreachable")
+		}
+
+		switch (payload).End.Tag() {
+		case TstzboundIncluded:
+			payload := (payload).End.Included()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 32)) = int8(int32(0))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 36)) = (((payload).Timestamp).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 40)) = int8(int32((((payload).Timestamp).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 41)) = int8(int32((((payload).Timestamp).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 44)) = int8(int32((((payload).Timestamp).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 45)) = int8(int32((((payload).Timestamp).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 46)) = int8(int32((((payload).Timestamp).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 48)) = int32((((payload).Timestamp).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 52)) = (payload).Offset
+
+		case TstzboundExcluded:
+			payload := (payload).End.Excluded()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 32)) = int8(int32(1))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 36)) = (((payload).Timestamp).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 40)) = int8(int32((((payload).Timestamp).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 41)) = int8(int32((((payload).Timestamp).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 44)) = int8(int32((((payload).Timestamp).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 45)) = int8(int32((((payload).Timestamp).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 46)) = int8(int32((((payload).Timestamp).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 48)) = int32((((payload).Timestamp).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 52)) = (payload).Offset
+
+		case TstzboundUnbounded:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 32)) = int8(int32(2))
+
+		default:
+			panic("unreachable")
+		}
+
+	case DbValueDaterange:
+		payload := value.Daterange()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(33))
+
+		switch (payload).Start.Tag() {
+		case DateboundIncluded:
+			payload := (payload).Start.Included()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(0))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 17)) = int8(int32((payload).Day))
+
+		case DateboundExcluded:
+			payload := (payload).Start.Excluded()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(1))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 16)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 17)) = int8(int32((payload).Day))
+
+		case DateboundUnbounded:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int8(int32(2))
+
+		default:
+			panic("unreachable")
+		}
+
+		switch (payload).End.Tag() {
+		case DateboundIncluded:
+			payload := (payload).End.Included()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 20)) = int8(int32(0))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 24)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 28)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 29)) = int8(int32((payload).Day))
+
+		case DateboundExcluded:
+			payload := (payload).End.Excluded()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 20)) = int8(int32(1))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 24)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 28)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 29)) = int8(int32((payload).Day))
+
+		case DateboundUnbounded:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 20)) = int8(int32(2))
+
+		default:
+			panic("unreachable")
+		}
+
+	case DbValueMoney:
+		payload := value.Money()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(34))
+		*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = payload
+
+	case DbValueOid:
+		payload := value.Oid()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(35))
+		*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = int32(payload)
+
+	case DbValueEnumeration:
+		payload := value.Enumeration()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(36))
+		utf817 := unsafe.Pointer(unsafe.StringData((payload).Name))
+		pinner.Pin(utf817)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(utf817)))
+		utf818 := unsafe.Pointer(unsafe.StringData((payload).Value))
+		pinner.Pin(utf818)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4))) = uint32(uint32(len((payload).Value)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))) = uint32(uintptr(uintptr(utf818)))
+
+	case DbValueComposite:
+		payload := value.Composite()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(37))
+		utf819 := unsafe.Pointer(unsafe.StringData((payload).Name))
+		pinner.Pin(utf819)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(utf819)))
+		slice20 := (payload).Values
+		length22 := uint32(len(slice20))
+		result21 := witRuntime.Allocate(pinner, uintptr(length22*4), 4)
+		for index, element := range slice20 {
+			base := unsafe.Add(result21, index*4)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).TakeHandle()
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4))) = uint32(length22)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))) = uint32(uintptr(uintptr(result21)))
+
+	case DbValueDomain:
+		payload := value.Domain()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(38))
+		utf823 := unsafe.Pointer(unsafe.StringData((payload).Name))
+		pinner.Pin(utf823)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(utf823)))
+		*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))) = ((payload).Value).TakeHandle()
+
+	case DbValueArray:
+		payload := value.Array()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(39))
+		slice24 := payload
+		length26 := uint32(len(slice24))
+		result25 := witRuntime.Allocate(pinner, uintptr(length26*4), 4)
+		for index, element := range slice24 {
+			base := unsafe.Add(result25, index*4)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).TakeHandle()
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(length26)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(result25)))
+
+	case DbValueRange:
+		payload := value.Range()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(40))
+		utf827 := unsafe.Pointer(unsafe.StringData((payload).Name))
+		pinner.Pin(utf827)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(utf827)))
+
+		switch ((payload).Value).Start.Tag() {
+		case ValueBoundIncluded:
+			payload := ((payload).Value).Start.Included()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))) = int8(int32(0))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (12 + 2*4))) = (payload).TakeHandle()
+
+		case ValueBoundExcluded:
+			payload := ((payload).Value).Start.Excluded()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))) = int8(int32(1))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (12 + 2*4))) = (payload).TakeHandle()
+
+		case ValueBoundUnbounded:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))) = int8(int32(2))
+
+		default:
+			panic("unreachable")
+		}
+
+		switch ((payload).Value).End.Tag() {
+		case ValueBoundIncluded:
+			payload := ((payload).Value).End.Included()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4))) = int8(int32(0))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (20 + 2*4))) = (payload).TakeHandle()
+
+		case ValueBoundExcluded:
+			payload := ((payload).Value).End.Excluded()
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4))) = int8(int32(1))
+			*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (20 + 2*4))) = (payload).TakeHandle()
+
+		case ValueBoundUnbounded:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4))) = int8(int32(2))
+
+		default:
+			panic("unreachable")
+		}
+
+	case DbValueNull:
+
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(41))
+
+	case DbValueVector:
+		payload := value.Vector()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(42))
+		data28 := unsafe.Pointer(unsafe.SliceData(payload))
+		pinner.Pin(data28)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uint32(len(payload)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(data28)))
+
+	case DbValueHalfvec:
+		payload := value.Halfvec()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(43))
+		data29 := unsafe.Pointer(unsafe.SliceData(payload))
+		pinner.Pin(data29)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uint32(len(payload)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = uint32(uintptr(uintptr(data29)))
+
+	case DbValueSparsevec:
+		payload := value.Sparsevec()
+		*(*int8)(unsafe.Add(unsafe.Pointer(returnArea), 0)) = int8(int32(44))
+		*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)) = (payload).Dim
+		data30 := unsafe.Pointer(unsafe.SliceData((payload).Indices))
+		pinner.Pin(data30)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))) = uint32(uint32(len((payload).Indices)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))) = uint32(uintptr(uintptr(data30)))
+		data31 := unsafe.Pointer(unsafe.SliceData((payload).Values))
+		pinner.Pin(data31)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 4*4))) = uint32(uint32(len((payload).Values)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4))) = uint32(uintptr(uintptr(data31)))
+
+	default:
+		panic("unreachable")
+	}
+	result32 := wasm_import_constructor_lazy_db_value(returnArea)
+	return LazyDbValueFromOwnHandle(int32(uintptr(result32)))
+
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [method]lazy-db-value.get
+func wasm_import_method_lazy_db_value_get(arg0 int32, arg1 uintptr)
+
+func (self *LazyDbValue) Get() DbValue {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 56, 8))
+	wasm_import_method_lazy_db_value_get((self).Handle(), returnArea)
+	var variant39 DbValue
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		variant39 = MakeDbValueCharacter(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))))
+
+	case 1:
+
+		variant39 = MakeDbValueInt2(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))))
+
+	case 2:
+
+		variant39 = MakeDbValueInt4(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))
+
+	case 3:
+
+		variant39 = MakeDbValueInt8(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8)))
+
+	case 4:
+
+		variant39 = MakeDbValueFloat4(*(*float32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))
+
+	case 5:
+
+		variant39 = MakeDbValueFloat8(*(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 8)))
+
+	case 6:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		variant39 = MakeDbValueNumeric(value)
+
+	case 7:
+
+		variant39 = MakeDbValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) != 0))
+
+	case 8:
+		value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		variant39 = MakeDbValueText(value0)
+
+	case 9:
+		value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		variant39 = MakeDbValueVarchar(value1)
+
+	case 10:
+		value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		variant39 = MakeDbValueBpchar(value2)
+
+	case 11:
+
+		variant39 = MakeDbValueTimestamp(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 13))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 17)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 18)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 20)))}})
+
+	case 12:
+
+		variant39 = MakeDbValueTimestamptz(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 13))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 17)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 18)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 20)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 24))})
+
+	case 13:
+
+		variant39 = MakeDbValueDate(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 13))))})
+
+	case 14:
+
+		variant39 = MakeDbValueTime(golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 9)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 10)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)))})
+
+	case 15:
+
+		variant39 = MakeDbValueTimetz(golem_rdbms_types.Timetz{golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 9)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 10)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)))}, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 16))})
+
+	case 16:
+
+		variant39 = MakeDbValueInterval(Interval{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)), *(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16))})
+
+	case 17:
+		value3 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		variant39 = MakeDbValueBytea(value3)
+
+	case 18:
+		value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		variant39 = MakeDbValueJson(value4)
+
+	case 19:
+		value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		variant39 = MakeDbValueJsonb(value5)
+
+	case 20:
+		value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		variant39 = MakeDbValueJsonpath(value6)
+
+	case 21:
+		value7 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		variant39 = MakeDbValueXml(value7)
+
+	case 22:
+
+		variant39 = MakeDbValueUuid(golem_rdbms_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)))})
+
+	case 23:
+		var variant golem_rdbms_types.IpAddress
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+
+			variant = golem_rdbms_types.MakeIpAddressIpv4(witTypes.Tuple4[uint8, uint8, uint8, uint8]{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 10)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 11)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 13))))})
+
+		case 1:
+
+			variant = golem_rdbms_types.MakeIpAddressIpv6(witTypes.Tuple8[uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint16]{uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 10)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 12)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 14)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 18)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 20)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 22)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 24))))})
+
+		default:
+			panic("unreachable")
+		}
+
+		variant39 = MakeDbValueInet(variant)
+
+	case 24:
+		var variant8 golem_rdbms_types.IpAddress
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+
+			variant8 = golem_rdbms_types.MakeIpAddressIpv4(witTypes.Tuple4[uint8, uint8, uint8, uint8]{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 10)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 11)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 13))))})
+
+		case 1:
+
+			variant8 = golem_rdbms_types.MakeIpAddressIpv6(witTypes.Tuple8[uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint16]{uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 10)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 12)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 14)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 18)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 20)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 22)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 24))))})
+
+		default:
+			panic("unreachable")
+		}
+
+		variant39 = MakeDbValueCidr(variant8)
+
+	case 25:
+
+		variant39 = MakeDbValueMacaddr(golem_rdbms_types.MacAddress{witTypes.Tuple6[uint8, uint8, uint8, uint8, uint8, uint8]{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 9)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 10)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 11)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 13))))}})
+
+	case 26:
+		result := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))), index*1)
+
+			result = append(result, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+		}
+
+		variant39 = MakeDbValueBit(result)
+
+	case 27:
+		result9 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))), index*1)
+
+			result9 = append(result9, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+		}
+
+		variant39 = MakeDbValueVarbit(result9)
+
+	case 28:
+		var variant10 Int4bound
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+
+			variant10 = MakeInt4boundIncluded(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)))
+
+		case 1:
+
+			variant10 = MakeInt4boundExcluded(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)))
+
+		case 2:
+
+			variant10 = MakeInt4boundUnbounded()
+
+		default:
+			panic("unreachable")
+		}
+		var variant11 Int4bound
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+		case 0:
+
+			variant11 = MakeInt4boundIncluded(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 20)))
+
+		case 1:
+
+			variant11 = MakeInt4boundExcluded(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 20)))
+
+		case 2:
+
+			variant11 = MakeInt4boundUnbounded()
+
+		default:
+			panic("unreachable")
+		}
+
+		variant39 = MakeDbValueInt4range(Int4range{variant10, variant11})
+
+	case 29:
+		var variant12 Int8bound
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+
+			variant12 = MakeInt8boundIncluded(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)))
+
+		case 1:
+
+			variant12 = MakeInt8boundExcluded(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16)))
+
+		case 2:
+
+			variant12 = MakeInt8boundUnbounded()
+
+		default:
+			panic("unreachable")
+		}
+		var variant13 Int8bound
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 24))) {
+		case 0:
+
+			variant13 = MakeInt8boundIncluded(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 32)))
+
+		case 1:
+
+			variant13 = MakeInt8boundExcluded(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 32)))
+
+		case 2:
+
+			variant13 = MakeInt8boundUnbounded()
+
+		default:
+			panic("unreachable")
+		}
+
+		variant39 = MakeDbValueInt8range(Int8range{variant12, variant13})
+
+	case 30:
+		var variant16 Numbound
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+			value14 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant16 = MakeNumboundIncluded(value14)
+
+		case 1:
+			value15 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant16 = MakeNumboundExcluded(value15)
+
+		case 2:
+
+			variant16 = MakeNumboundUnbounded()
+
+		default:
+			panic("unreachable")
+		}
+		var variant19 Numbound
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4)))) {
+		case 0:
+			value17 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 5*4))))
+
+			variant19 = MakeNumboundIncluded(value17)
+
+		case 1:
+			value18 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 5*4))))
+
+			variant19 = MakeNumboundExcluded(value18)
+
+		case 2:
+
+			variant19 = MakeNumboundUnbounded()
+
+		default:
+			panic("unreachable")
+		}
+
+		variant39 = MakeDbValueNumrange(Numrange{variant16, variant19})
+
+	case 31:
+		var variant20 Tsbound
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+
+			variant20 = MakeTsboundIncluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 24)))}})
+
+		case 1:
+
+			variant20 = MakeTsboundExcluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 24)))}})
+
+		case 2:
+
+			variant20 = MakeTsboundUnbounded()
+
+		default:
+			panic("unreachable")
+		}
+		var variant21 Tsbound
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 28))) {
+		case 0:
+
+			variant21 = MakeTsboundIncluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 32)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 36)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 37))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 41)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 42)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 44)))}})
+
+		case 1:
+
+			variant21 = MakeTsboundExcluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 32)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 36)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 37))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 41)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 42)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 44)))}})
+
+		case 2:
+
+			variant21 = MakeTsboundUnbounded()
+
+		default:
+			panic("unreachable")
+		}
+
+		variant39 = MakeDbValueTsrange(Tsrange{variant20, variant21})
+
+	case 32:
+		var variant22 Tstzbound
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+
+			variant22 = MakeTstzboundIncluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 24)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 28))})
+
+		case 1:
+
+			variant22 = MakeTstzboundExcluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 24)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 28))})
+
+		case 2:
+
+			variant22 = MakeTstzboundUnbounded()
+
+		default:
+			panic("unreachable")
+		}
+		var variant23 Tstzbound
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 32))) {
+		case 0:
+
+			variant23 = MakeTstzboundIncluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 36)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 41))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 44)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 45)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 46)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 48)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 52))})
+
+		case 1:
+
+			variant23 = MakeTstzboundExcluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 36)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 41))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 44)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 45)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 46)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 48)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 52))})
+
+		case 2:
+
+			variant23 = MakeTstzboundUnbounded()
+
+		default:
+			panic("unreachable")
+		}
+
+		variant39 = MakeDbValueTstzrange(Tstzrange{variant22, variant23})
+
+	case 33:
+		var variant24 Datebound
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+
+			variant24 = MakeDateboundIncluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 17))))})
+
+		case 1:
+
+			variant24 = MakeDateboundExcluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 17))))})
+
+		case 2:
+
+			variant24 = MakeDateboundUnbounded()
+
+		default:
+			panic("unreachable")
+		}
+		var variant25 Datebound
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 20))) {
+		case 0:
+
+			variant25 = MakeDateboundIncluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 24)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 28)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 29))))})
+
+		case 1:
+
+			variant25 = MakeDateboundExcluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 24)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 28)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 29))))})
+
+		case 2:
+
+			variant25 = MakeDateboundUnbounded()
+
+		default:
+			panic("unreachable")
+		}
+
+		variant39 = MakeDbValueDaterange(Daterange{variant24, variant25})
+
+	case 34:
+
+		variant39 = MakeDbValueMoney(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8)))
+
+	case 35:
+
+		variant39 = MakeDbValueOid(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))
+
+	case 36:
+		value26 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+		value27 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4))))
+
+		variant39 = MakeDbValueEnumeration(Enumeration{value26, value27})
+
+	case 37:
+		value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+		result29 := make([]*LazyDbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))), index*4)
+
+			result29 = append(result29, LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 0))))))
+		}
+
+		variant39 = MakeDbValueComposite(Composite{value28, result29})
+
+	case 38:
+		value30 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		variant39 = MakeDbValueDomain(Domain{value30, LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))))})
+
+	case 39:
+		result31 := make([]*LazyDbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))), index*4)
+
+			result31 = append(result31, LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 0))))))
+		}
+
+		variant39 = MakeDbValueArray(result31)
+
+	case 40:
+		value32 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+		var variant33 ValueBound
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4)))) {
+		case 0:
+
+			variant33 = MakeValueBoundIncluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (12 + 2*4)))))))
+
+		case 1:
+
+			variant33 = MakeValueBoundExcluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (12 + 2*4)))))))
+
+		case 2:
+
+			variant33 = MakeValueBoundUnbounded()
+
+		default:
+			panic("unreachable")
+		}
+		var variant34 ValueBound
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4)))) {
+		case 0:
+
+			variant34 = MakeValueBoundIncluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (20 + 2*4)))))))
+
+		case 1:
+
+			variant34 = MakeValueBoundExcluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (20 + 2*4)))))))
+
+		case 2:
+
+			variant34 = MakeValueBoundUnbounded()
+
+		default:
+			panic("unreachable")
+		}
+
+		variant39 = MakeDbValueRange(Range{value32, ValuesRange{variant33, variant34}})
+
+	case 41:
+
+		variant39 = MakeDbValueNull()
+
+	case 42:
+		value35 := unsafe.Slice((*float32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		variant39 = MakeDbValueVector(value35)
+
+	case 43:
+		value36 := unsafe.Slice((*float32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		variant39 = MakeDbValueHalfvec(value36)
+
+	case 44:
+		value37 := unsafe.Slice((*int32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+		value38 := unsafe.Slice((*float32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 4*4))))
+
+		variant39 = MakeDbValueSparsevec(SparseVec{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)), value37, value38})
+
+	default:
+		panic("unreachable")
+	}
+	result40 := variant39
+	return result40
+
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [constructor]lazy-db-column-type
+func wasm_import_constructor_lazy_db_column_type(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32) int32
+
+func MakeLazyDbColumnType(value DbColumnType) *LazyDbColumnType {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	var variant int32
+	var variant4 uintptr
+	var variant5 uint32
+	var variant6 uintptr
+	var variant7 uint32
+	switch value.Tag() {
+	case DbColumnTypeCharacter:
+
+		variant = int32(0)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeInt2:
+
+		variant = int32(1)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeInt4:
+
+		variant = int32(2)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeInt8:
+
+		variant = int32(3)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeFloat4:
+
+		variant = int32(4)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeFloat8:
+
+		variant = int32(5)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeNumeric:
+
+		variant = int32(6)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeBoolean:
+
+		variant = int32(7)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeText:
+
+		variant = int32(8)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeVarchar:
+
+		variant = int32(9)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeBpchar:
+
+		variant = int32(10)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeTimestamp:
+
+		variant = int32(11)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeTimestamptz:
+
+		variant = int32(12)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeDate:
+
+		variant = int32(13)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeTime:
+
+		variant = int32(14)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeTimetz:
+
+		variant = int32(15)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeInterval:
+
+		variant = int32(16)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeBytea:
+
+		variant = int32(17)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeUuid:
+
+		variant = int32(18)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeXml:
+
+		variant = int32(19)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeJson:
+
+		variant = int32(20)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeJsonb:
+
+		variant = int32(21)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeJsonpath:
+
+		variant = int32(22)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeInet:
+
+		variant = int32(23)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeCidr:
+
+		variant = int32(24)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeMacaddr:
+
+		variant = int32(25)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeBit:
+
+		variant = int32(26)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeVarbit:
+
+		variant = int32(27)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeInt4range:
+
+		variant = int32(28)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeInt8range:
+
+		variant = int32(29)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeNumrange:
+
+		variant = int32(30)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeTsrange:
+
+		variant = int32(31)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeTstzrange:
+
+		variant = int32(32)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeDaterange:
+
+		variant = int32(33)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeMoney:
+
+		variant = int32(34)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeOid:
+
+		variant = int32(35)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeEnumeration:
+		payload := value.Enumeration()
+		utf8 := unsafe.Pointer(unsafe.StringData((payload).Name))
+		pinner.Pin(utf8)
+
+		variant = int32(36)
+		variant4 = uintptr(utf8)
+		variant5 = uint32(len((payload).Name))
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeComposite:
+		payload := value.Composite()
+		utf80 := unsafe.Pointer(unsafe.StringData((payload).Name))
+		pinner.Pin(utf80)
+		slice := (payload).Attributes
+		length := uint32(len(slice))
+		result := witRuntime.Allocate(pinner, uintptr(length*(3*4)), 4)
+		for index, element := range slice {
+			base := unsafe.Add(result, index*(3*4))
+			utf81 := unsafe.Pointer(unsafe.StringData((element).F0))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).F0)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf81)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = ((element).F1).TakeHandle()
+
+		}
+
+		variant = int32(37)
+		variant4 = uintptr(utf80)
+		variant5 = uint32(len((payload).Name))
+		variant6 = uintptr(result)
+		variant7 = length
+
+	case DbColumnTypeDomain:
+		payload := value.Domain()
+		utf82 := unsafe.Pointer(unsafe.StringData((payload).Name))
+		pinner.Pin(utf82)
+
+		variant = int32(38)
+		variant4 = uintptr(utf82)
+		variant5 = uint32(len((payload).Name))
+		variant6 = uintptr(((payload).BaseType).TakeHandle())
+		variant7 = 0
+
+	case DbColumnTypeArray:
+		payload := value.Array()
+
+		variant = int32(39)
+		variant4 = uintptr((payload).TakeHandle())
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeRange:
+		payload := value.Range()
+		utf83 := unsafe.Pointer(unsafe.StringData((payload).Name))
+		pinner.Pin(utf83)
+
+		variant = int32(40)
+		variant4 = uintptr(utf83)
+		variant5 = uint32(len((payload).Name))
+		variant6 = uintptr(((payload).BaseType).TakeHandle())
+		variant7 = 0
+
+	case DbColumnTypeVector:
+
+		variant = int32(41)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeHalfvec:
+
+		variant = int32(42)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	case DbColumnTypeSparsevec:
+
+		variant = int32(43)
+		variant4 = 0
+		variant5 = 0
+		variant6 = 0
+		variant7 = 0
+
+	default:
+		panic("unreachable")
+	}
+	result8 := wasm_import_constructor_lazy_db_column_type(variant, variant4, variant5, variant6, variant7)
+	return LazyDbColumnTypeFromOwnHandle(int32(uintptr(result8)))
+
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [method]lazy-db-column-type.get
+func wasm_import_method_lazy_db_column_type_get(arg0 int32, arg1 uintptr)
+
+func (self *LazyDbColumnType) Get() DbColumnType {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	wasm_import_method_lazy_db_column_type_get((self).Handle(), returnArea)
+	var variant DbColumnType
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		variant = MakeDbColumnTypeCharacter()
+
+	case 1:
+
+		variant = MakeDbColumnTypeInt2()
+
+	case 2:
+
+		variant = MakeDbColumnTypeInt4()
+
+	case 3:
+
+		variant = MakeDbColumnTypeInt8()
+
+	case 4:
+
+		variant = MakeDbColumnTypeFloat4()
+
+	case 5:
+
+		variant = MakeDbColumnTypeFloat8()
+
+	case 6:
+
+		variant = MakeDbColumnTypeNumeric()
+
+	case 7:
+
+		variant = MakeDbColumnTypeBoolean()
+
+	case 8:
+
+		variant = MakeDbColumnTypeText()
+
+	case 9:
+
+		variant = MakeDbColumnTypeVarchar()
+
+	case 10:
+
+		variant = MakeDbColumnTypeBpchar()
+
+	case 11:
+
+		variant = MakeDbColumnTypeTimestamp()
+
+	case 12:
+
+		variant = MakeDbColumnTypeTimestamptz()
+
+	case 13:
+
+		variant = MakeDbColumnTypeDate()
+
+	case 14:
+
+		variant = MakeDbColumnTypeTime()
+
+	case 15:
+
+		variant = MakeDbColumnTypeTimetz()
+
+	case 16:
+
+		variant = MakeDbColumnTypeInterval()
+
+	case 17:
+
+		variant = MakeDbColumnTypeBytea()
+
+	case 18:
+
+		variant = MakeDbColumnTypeUuid()
+
+	case 19:
+
+		variant = MakeDbColumnTypeXml()
+
+	case 20:
+
+		variant = MakeDbColumnTypeJson()
+
+	case 21:
+
+		variant = MakeDbColumnTypeJsonb()
+
+	case 22:
+
+		variant = MakeDbColumnTypeJsonpath()
+
+	case 23:
+
+		variant = MakeDbColumnTypeInet()
+
+	case 24:
+
+		variant = MakeDbColumnTypeCidr()
+
+	case 25:
+
+		variant = MakeDbColumnTypeMacaddr()
+
+	case 26:
+
+		variant = MakeDbColumnTypeBit()
+
+	case 27:
+
+		variant = MakeDbColumnTypeVarbit()
+
+	case 28:
+
+		variant = MakeDbColumnTypeInt4range()
+
+	case 29:
+
+		variant = MakeDbColumnTypeInt8range()
+
+	case 30:
+
+		variant = MakeDbColumnTypeNumrange()
+
+	case 31:
+
+		variant = MakeDbColumnTypeTsrange()
+
+	case 32:
+
+		variant = MakeDbColumnTypeTstzrange()
+
+	case 33:
+
+		variant = MakeDbColumnTypeDaterange()
+
+	case 34:
+
+		variant = MakeDbColumnTypeMoney()
+
+	case 35:
+
+		variant = MakeDbColumnTypeOid()
+
+	case 36:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		variant = MakeDbColumnTypeEnumeration(EnumerationType{value})
+
+	case 37:
+		value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		result := make([]witTypes.Tuple2[string, *LazyDbColumnType], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))), index*(3*4))
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+			result = append(result, witTypes.Tuple2[string, *LazyDbColumnType]{value1, LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))))})
+		}
+
+		variant = MakeDbColumnTypeComposite(CompositeType{value0, result})
+
+	case 38:
+		value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		variant = MakeDbColumnTypeDomain(DomainType{value2, LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))))})
+
+	case 39:
+
+		variant = MakeDbColumnTypeArray(LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+
+	case 40:
+		value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		variant = MakeDbColumnTypeRange(RangeType{value3, LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))))})
+
+	case 41:
+
+		variant = MakeDbColumnTypeVector()
+
+	case 42:
+
+		variant = MakeDbColumnTypeHalfvec()
+
+	case 43:
+
+		variant = MakeDbColumnTypeSparsevec()
+
+	default:
+		panic("unreachable")
+	}
+	result4 := variant
+	return result4
+
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [method]db-result-stream.get-columns
+func wasm_import_method_db_result_stream_get_columns(arg0 int32, arg1 uintptr)
+
+func (self *DbResultStream) GetColumns() []DbColumn {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	wasm_import_method_db_result_stream_get_columns((self).Handle(), returnArea)
+	result6 := make([]DbColumn, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)))), index*(16+8*4))
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+		var variant DbColumnType
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+		case 0:
+
+			variant = MakeDbColumnTypeCharacter()
+
+		case 1:
+
+			variant = MakeDbColumnTypeInt2()
+
+		case 2:
+
+			variant = MakeDbColumnTypeInt4()
+
+		case 3:
+
+			variant = MakeDbColumnTypeInt8()
+
+		case 4:
+
+			variant = MakeDbColumnTypeFloat4()
+
+		case 5:
+
+			variant = MakeDbColumnTypeFloat8()
+
+		case 6:
+
+			variant = MakeDbColumnTypeNumeric()
+
+		case 7:
+
+			variant = MakeDbColumnTypeBoolean()
+
+		case 8:
+
+			variant = MakeDbColumnTypeText()
+
+		case 9:
+
+			variant = MakeDbColumnTypeVarchar()
+
+		case 10:
+
+			variant = MakeDbColumnTypeBpchar()
+
+		case 11:
+
+			variant = MakeDbColumnTypeTimestamp()
+
+		case 12:
+
+			variant = MakeDbColumnTypeTimestamptz()
+
+		case 13:
+
+			variant = MakeDbColumnTypeDate()
+
+		case 14:
+
+			variant = MakeDbColumnTypeTime()
+
+		case 15:
+
+			variant = MakeDbColumnTypeTimetz()
+
+		case 16:
+
+			variant = MakeDbColumnTypeInterval()
+
+		case 17:
+
+			variant = MakeDbColumnTypeBytea()
+
+		case 18:
+
+			variant = MakeDbColumnTypeUuid()
+
+		case 19:
+
+			variant = MakeDbColumnTypeXml()
+
+		case 20:
+
+			variant = MakeDbColumnTypeJson()
+
+		case 21:
+
+			variant = MakeDbColumnTypeJsonb()
+
+		case 22:
+
+			variant = MakeDbColumnTypeJsonpath()
+
+		case 23:
+
+			variant = MakeDbColumnTypeInet()
+
+		case 24:
+
+			variant = MakeDbColumnTypeCidr()
+
+		case 25:
+
+			variant = MakeDbColumnTypeMacaddr()
+
+		case 26:
+
+			variant = MakeDbColumnTypeBit()
+
+		case 27:
+
+			variant = MakeDbColumnTypeVarbit()
+
+		case 28:
+
+			variant = MakeDbColumnTypeInt4range()
+
+		case 29:
+
+			variant = MakeDbColumnTypeInt8range()
+
+		case 30:
+
+			variant = MakeDbColumnTypeNumrange()
+
+		case 31:
+
+			variant = MakeDbColumnTypeTsrange()
+
+		case 32:
+
+			variant = MakeDbColumnTypeTstzrange()
+
+		case 33:
+
+			variant = MakeDbColumnTypeDaterange()
+
+		case 34:
+
+			variant = MakeDbColumnTypeMoney()
+
+		case 35:
+
+			variant = MakeDbColumnTypeOid()
+
+		case 36:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+			variant = MakeDbColumnTypeEnumeration(EnumerationType{value0})
+
+		case 37:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+			result := make([]witTypes.Tuple2[string, *LazyDbColumnType], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(3*4))
+				value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+				result = append(result, witTypes.Tuple2[string, *LazyDbColumnType]{value2, LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))))})
+			}
+
+			variant = MakeDbColumnTypeComposite(CompositeType{value1, result})
+
+		case 38:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+			variant = MakeDbColumnTypeDomain(DomainType{value3, LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))))})
+
+		case 39:
+
+			variant = MakeDbColumnTypeArray(LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))))
+
+		case 40:
+			value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+			variant = MakeDbColumnTypeRange(RangeType{value4, LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))))})
+
+		case 41:
+
+			variant = MakeDbColumnTypeVector()
+
+		case 42:
+
+			variant = MakeDbColumnTypeHalfvec()
+
+		case 43:
+
+			variant = MakeDbColumnTypeSparsevec()
+
+		default:
+			panic("unreachable")
+		}
+		value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+
+		result6 = append(result6, DbColumn{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), value, variant, value5})
+	}
+
+	result7 := result6
+	return result7
+
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [method]db-result-stream.get-next
+func wasm_import_method_db_result_stream_get_next(arg0 int32, arg1 uintptr)
+
+func (self *DbResultStream) GetNext() witTypes.Option[[]DbRow] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_method_db_result_stream_get_next((self).Handle(), returnArea)
+	var option witTypes.Option[[]DbRow]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[[]DbRow]()
+	case 1:
+		result41 := make([]DbRow, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(2*4))
+			result40 := make([]DbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*56)
+				var variant39 DbValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant39 = MakeDbValueCharacter(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 1:
+
+					variant39 = MakeDbValueInt2(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 2:
+
+					variant39 = MakeDbValueInt4(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 3:
+
+					variant39 = MakeDbValueInt8(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 4:
+
+					variant39 = MakeDbValueFloat4(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 5:
+
+					variant39 = MakeDbValueFloat8(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 6:
+					value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueNumeric(value)
+
+				case 7:
+
+					variant39 = MakeDbValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+				case 8:
+					value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueText(value0)
+
+				case 9:
+					value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueVarchar(value1)
+
+				case 10:
+					value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueBpchar(value2)
+
+				case 11:
+
+					variant39 = MakeDbValueTimestamp(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))}})
+
+				case 12:
+
+					variant39 = MakeDbValueTimestamptz(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 24))})
+
+				case 13:
+
+					variant39 = MakeDbValueDate(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))})
+
+				case 14:
+
+					variant39 = MakeDbValueTime(golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+				case 15:
+
+					variant39 = MakeDbValueTimetz(golem_rdbms_types.Timetz{golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+				case 16:
+
+					variant39 = MakeDbValueInterval(Interval{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), *(*int64)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+				case 17:
+					value3 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueBytea(value3)
+
+				case 18:
+					value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueJson(value4)
+
+				case 19:
+					value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueJsonb(value5)
+
+				case 20:
+					value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueJsonpath(value6)
+
+				case 21:
+					value7 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueXml(value7)
+
+				case 22:
+
+					variant39 = MakeDbValueUuid(golem_rdbms_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+				case 23:
+					var variant golem_rdbms_types.IpAddress
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant = golem_rdbms_types.MakeIpAddressIpv4(witTypes.Tuple4[uint8, uint8, uint8, uint8]{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 11)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))})
+
+					case 1:
+
+						variant = golem_rdbms_types.MakeIpAddressIpv6(witTypes.Tuple8[uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint16]{uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 14)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))})
+
+					default:
+						panic("unreachable")
+					}
+
+					variant39 = MakeDbValueInet(variant)
+
+				case 24:
+					var variant8 golem_rdbms_types.IpAddress
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant8 = golem_rdbms_types.MakeIpAddressIpv4(witTypes.Tuple4[uint8, uint8, uint8, uint8]{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 11)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))})
+
+					case 1:
+
+						variant8 = golem_rdbms_types.MakeIpAddressIpv6(witTypes.Tuple8[uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint16]{uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 14)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))})
+
+					default:
+						panic("unreachable")
+					}
+
+					variant39 = MakeDbValueCidr(variant8)
+
+				case 25:
+
+					variant39 = MakeDbValueMacaddr(golem_rdbms_types.MacAddress{witTypes.Tuple6[uint8, uint8, uint8, uint8, uint8, uint8]{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 11)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))}})
+
+				case 26:
+					result := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+						result = append(result, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+					}
+
+					variant39 = MakeDbValueBit(result)
+
+				case 27:
+					result9 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+						result9 = append(result9, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+					}
+
+					variant39 = MakeDbValueVarbit(result9)
+
+				case 28:
+					var variant10 Int4bound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant10 = MakeInt4boundIncluded(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+
+					case 1:
+
+						variant10 = MakeInt4boundExcluded(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+
+					case 2:
+
+						variant10 = MakeInt4boundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant11 Int4bound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						variant11 = MakeInt4boundIncluded(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+
+					case 1:
+
+						variant11 = MakeInt4boundExcluded(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+
+					case 2:
+
+						variant11 = MakeInt4boundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant39 = MakeDbValueInt4range(Int4range{variant10, variant11})
+
+				case 29:
+					var variant12 Int8bound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant12 = MakeInt8boundIncluded(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))
+
+					case 1:
+
+						variant12 = MakeInt8boundExcluded(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))
+
+					case 2:
+
+						variant12 = MakeInt8boundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant13 Int8bound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+					case 0:
+
+						variant13 = MakeInt8boundIncluded(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 1:
+
+						variant13 = MakeInt8boundExcluded(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 2:
+
+						variant13 = MakeInt8boundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant39 = MakeDbValueInt8range(Int8range{variant12, variant13})
+
+				case 30:
+					var variant16 Numbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+						value14 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+						variant16 = MakeNumboundIncluded(value14)
+
+					case 1:
+						value15 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+						variant16 = MakeNumboundExcluded(value15)
+
+					case 2:
+
+						variant16 = MakeNumboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant19 Numbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+					case 0:
+						value17 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+
+						variant19 = MakeNumboundIncluded(value17)
+
+					case 1:
+						value18 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+
+						variant19 = MakeNumboundExcluded(value18)
+
+					case 2:
+
+						variant19 = MakeNumboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant39 = MakeDbValueNumrange(Numrange{variant16, variant19})
+
+				case 31:
+					var variant20 Tsbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant20 = MakeTsboundIncluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}})
+
+					case 1:
+
+						variant20 = MakeTsboundExcluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}})
+
+					case 2:
+
+						variant20 = MakeTsboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant21 Tsbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 28))) {
+					case 0:
+
+						variant21 = MakeTsboundIncluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 36)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 37))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 41)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 42)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)))}})
+
+					case 1:
+
+						variant21 = MakeTsboundExcluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 36)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 37))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 41)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 42)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)))}})
+
+					case 2:
+
+						variant21 = MakeTsboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant39 = MakeDbValueTsrange(Tsrange{variant20, variant21})
+
+				case 32:
+					var variant22 Tstzbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant22 = MakeTstzboundIncluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 28))})
+
+					case 1:
+
+						variant22 = MakeTstzboundExcluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 28))})
+
+					case 2:
+
+						variant22 = MakeTstzboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant23 Tstzbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+					case 0:
+
+						variant23 = MakeTstzboundIncluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 41))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 44)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 45)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 46)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 52))})
+
+					case 1:
+
+						variant23 = MakeTstzboundExcluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 41))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 44)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 45)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 46)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 52))})
+
+					case 2:
+
+						variant23 = MakeTstzboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant39 = MakeDbValueTstzrange(Tstzrange{variant22, variant23})
+
+				case 33:
+					var variant24 Datebound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant24 = MakeDateboundIncluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))})
+
+					case 1:
+
+						variant24 = MakeDateboundExcluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))})
+
+					case 2:
+
+						variant24 = MakeDateboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant25 Datebound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20))) {
+					case 0:
+
+						variant25 = MakeDateboundIncluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 28)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 29))))})
+
+					case 1:
+
+						variant25 = MakeDateboundExcluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 28)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 29))))})
+
+					case 2:
+
+						variant25 = MakeDateboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant39 = MakeDbValueDaterange(Daterange{variant24, variant25})
+
+				case 34:
+
+					variant39 = MakeDbValueMoney(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 35:
+
+					variant39 = MakeDbValueOid(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 36:
+					value26 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					value27 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+					variant39 = MakeDbValueEnumeration(Enumeration{value26, value27})
+
+				case 37:
+					value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					result29 := make([]*LazyDbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*4)
+
+						result29 = append(result29, LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 0))))))
+					}
+
+					variant39 = MakeDbValueComposite(Composite{value28, result29})
+
+				case 38:
+					value30 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueDomain(Domain{value30, LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))))})
+
+				case 39:
+					result31 := make([]*LazyDbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result31 = append(result31, LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 0))))))
+					}
+
+					variant39 = MakeDbValueArray(result31)
+
+				case 40:
+					value32 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					var variant33 ValueBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						variant33 = MakeValueBoundIncluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4)))))))
+
+					case 1:
+
+						variant33 = MakeValueBoundExcluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4)))))))
+
+					case 2:
+
+						variant33 = MakeValueBoundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant34 ValueBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) {
+					case 0:
+
+						variant34 = MakeValueBoundIncluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4)))))))
+
+					case 1:
+
+						variant34 = MakeValueBoundExcluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4)))))))
+
+					case 2:
+
+						variant34 = MakeValueBoundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant39 = MakeDbValueRange(Range{value32, ValuesRange{variant33, variant34}})
+
+				case 41:
+
+					variant39 = MakeDbValueNull()
+
+				case 42:
+					value35 := unsafe.Slice((*float32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueVector(value35)
+
+				case 43:
+					value36 := unsafe.Slice((*float32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant39 = MakeDbValueHalfvec(value36)
+
+				case 44:
+					value37 := unsafe.Slice((*int32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+					value38 := unsafe.Slice((*float32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+					variant39 = MakeDbValueSparsevec(SparseVec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), value37, value38})
+
+				default:
+					panic("unreachable")
+				}
+
+				result40 = append(result40, variant39)
+			}
+
+			result41 = append(result41, DbRow{result40})
+		}
+
+		option = witTypes.Some[[]DbRow](result41)
+	default:
+		panic("unreachable")
+	}
+	result42 := option
+	return result42
+
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [static]db-connection.open
+func wasm_import_static_db_connection_open(arg0 uintptr, arg1 uint32, arg2 uintptr)
+
+func DbConnectionOpen(address string) witTypes.Result[*DbConnection, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(address))
+	pinner.Pin(utf8)
+	wasm_import_static_db_connection_open(uintptr(utf8), uint32(len(address)), returnArea)
+	var result witTypes.Result[*DbConnection, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[*DbConnection, Error](DbConnectionFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value0)
+
+		case 2:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value1)
+
+		case 3:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value2)
+
+		case 4:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value3)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[*DbConnection, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result4 := result
+	return result4
+
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [method]db-connection.query
+func wasm_import_method_db_connection_query(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbConnection) Query(statement string, params []DbValue) witTypes.Result[DbResult, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice33 := params
+	length35 := uint32(len(slice33))
+	result34 := witRuntime.Allocate(pinner, uintptr(length35*56), 8)
+	for index, element := range slice33 {
+		base := unsafe.Add(result34, index*56)
+
+		switch element.Tag() {
+		case DbValueCharacter:
+			payload := element.Character()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueInt2:
+			payload := element.Int2()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueInt4:
+			payload := element.Int4()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueInt8:
+			payload := element.Int8()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueFloat4:
+			payload := element.Float4()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueFloat8:
+			payload := element.Float8()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueNumeric:
+			payload := element.Numeric()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueBoolean:
+			payload := element.Boolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueText:
+			payload := element.Text()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueVarchar:
+			payload := element.Varchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			utf82 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf82)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf82)))
+
+		case DbValueBpchar:
+			payload := element.Bpchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			utf83 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf83)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf83)))
+
+		case DbValueTimestamp:
+			payload := element.Timestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTimestamptz:
+			payload := element.Timestamptz()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (((payload).Timestamp).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((((payload).Timestamp).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((((payload).Timestamp).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32((((payload).Timestamp).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32((((payload).Timestamp).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Offset
+
+		case DbValueDate:
+			payload := element.Date()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).Day))
+
+		case DbValueTime:
+			payload := element.Time()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Nanosecond)
+
+		case DbValueTimetz:
+			payload := element.Timetz()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32(((payload).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Offset
+
+		case DbValueInterval:
+			payload := element.Interval()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Months
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Days
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Microseconds
+
+		case DbValueBytea:
+			payload := element.Bytea()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		case DbValueJson:
+			payload := element.Json()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			utf84 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf84)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf84)))
+
+		case DbValueJsonb:
+			payload := element.Jsonb()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			utf85 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf85)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf85)))
+
+		case DbValueJsonpath:
+			payload := element.Jsonpath()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			utf86 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf86)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf86)))
+
+		case DbValueXml:
+			payload := element.Xml()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			utf87 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf87)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf87)))
+
+		case DbValueUuid:
+			payload := element.Uuid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).LowBits)
+
+		case DbValueInet:
+			payload := element.Inet()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+			switch payload.Tag() {
+			case golem_rdbms_types.IpAddressIpv4:
+				payload := payload.Ipv4()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).F0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32((payload).F1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).F2))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).F3))
+
+			case golem_rdbms_types.IpAddressIpv6:
+				payload := payload.Ipv6()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 10)) = int16(int32((payload).F0))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 12)) = int16(int32((payload).F1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 14)) = int16(int32((payload).F2))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 16)) = int16(int32((payload).F3))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 18)) = int16(int32((payload).F4))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 20)) = int16(int32((payload).F5))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 22)) = int16(int32((payload).F6))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 24)) = int16(int32((payload).F7))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueCidr:
+			payload := element.Cidr()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+			switch payload.Tag() {
+			case golem_rdbms_types.IpAddressIpv4:
+				payload := payload.Ipv4()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).F0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32((payload).F1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).F2))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).F3))
+
+			case golem_rdbms_types.IpAddressIpv6:
+				payload := payload.Ipv6()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 10)) = int16(int32((payload).F0))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 12)) = int16(int32((payload).F1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 14)) = int16(int32((payload).F2))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 16)) = int16(int32((payload).F3))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 18)) = int16(int32((payload).F4))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 20)) = int16(int32((payload).F5))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 22)) = int16(int32((payload).F6))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 24)) = int16(int32((payload).F7))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueMacaddr:
+			payload := element.Macaddr()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(((payload).Octets).F0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32(((payload).Octets).F1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32(((payload).Octets).F2))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32(((payload).Octets).F3))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Octets).F4))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Octets).F5))
+
+		case DbValueBit:
+			payload := element.Bit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			slice := payload
+			length := uint32(len(slice))
+			result9 := witRuntime.Allocate(pinner, uintptr(length*1), 1)
+			for index, element := range slice {
+				base := unsafe.Add(result9, index*1)
+				var result8 int32
+				if element {
+					result8 = 1
+				} else {
+					result8 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result8)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result9)))
+
+		case DbValueVarbit:
+			payload := element.Varbit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			slice11 := payload
+			length13 := uint32(len(slice11))
+			result12 := witRuntime.Allocate(pinner, uintptr(length13*1), 1)
+			for index, element := range slice11 {
+				base := unsafe.Add(result12, index*1)
+				var result10 int32
+				if element {
+					result10 = 1
+				} else {
+					result10 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result10)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length13)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result12)))
+
+		case DbValueInt4range:
+			payload := element.Int4range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+			switch (payload).Start.Tag() {
+			case Int4boundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			case Int4boundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			case Int4boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case Int4boundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			case Int4boundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			case Int4boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueInt8range:
+			payload := element.Int8range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+			switch (payload).Start.Tag() {
+			case Int8boundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			case Int8boundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			case Int8boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case Int8boundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+			case Int8boundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+			case Int8boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueNumrange:
+			payload := element.Numrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+
+			switch (payload).Start.Tag() {
+			case NumboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				utf814 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf814)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf814)))
+
+			case NumboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				utf815 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf815)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf815)))
+
+			case NumboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case NumboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+				utf816 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf816)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(utf816)))
+
+			case NumboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				utf817 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf817)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(utf817)))
+
+			case NumboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueTsrange:
+			payload := element.Tsrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+
+			switch (payload).Start.Tag() {
+			case TsboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case TsboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 36)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 37)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 42)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 36)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 37)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 42)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueTstzrange:
+			payload := element.Tstzrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+
+			switch (payload).Start.Tag() {
+			case TstzboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 28)) = (payload).Offset
+
+			case TstzboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 28)) = (payload).Offset
+
+			case TstzboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case TstzboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 44)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 45)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 46)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 52)) = (payload).Offset
+
+			case TstzboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 44)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 45)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 46)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 52)) = (payload).Offset
+
+			case TstzboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueDaterange:
+			payload := element.Daterange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+			switch (payload).Start.Tag() {
+			case DateboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((payload).Day))
+
+			case DateboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((payload).Day))
+
+			case DateboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case DateboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 29)) = int8(int32((payload).Day))
+
+			case DateboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 29)) = int8(int32((payload).Day))
+
+			case DateboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueMoney:
+			payload := element.Money()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueOid:
+			payload := element.Oid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueEnumeration:
+			payload := element.Enumeration()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36))
+			utf818 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf818)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf818)))
+			utf819 := unsafe.Pointer(unsafe.StringData((payload).Value))
+			pinner.Pin(utf819)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Value)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf819)))
+
+		case DbValueComposite:
+			payload := element.Composite()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(37))
+			utf820 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf820)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf820)))
+			slice21 := (payload).Values
+			length23 := uint32(len(slice21))
+			result22 := witRuntime.Allocate(pinner, uintptr(length23*4), 4)
+			for index, element := range slice21 {
+				base := unsafe.Add(result22, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).TakeHandle()
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length23)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result22)))
+
+		case DbValueDomain:
+			payload := element.Domain()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(38))
+			utf824 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf824)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf824)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = ((payload).Value).TakeHandle()
+
+		case DbValueArray:
+			payload := element.Array()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(39))
+			slice25 := payload
+			length27 := uint32(len(slice25))
+			result26 := witRuntime.Allocate(pinner, uintptr(length27*4), 4)
+			for index, element := range slice25 {
+				base := unsafe.Add(result26, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).TakeHandle()
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length27)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result26)))
+
+		case DbValueRange:
+			payload := element.Range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(40))
+			utf828 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf828)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf828)))
+
+			switch ((payload).Value).Start.Tag() {
+			case ValueBoundIncluded:
+				payload := ((payload).Value).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundExcluded:
+				payload := ((payload).Value).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch ((payload).Value).End.Tag() {
+			case ValueBoundIncluded:
+				payload := ((payload).Value).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundExcluded:
+				payload := ((payload).Value).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(41))
+
+		case DbValueVector:
+			payload := element.Vector()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(42))
+			data29 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data29)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data29)))
+
+		case DbValueHalfvec:
+			payload := element.Halfvec()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(43))
+			data30 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data30)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data30)))
+
+		case DbValueSparsevec:
+			payload := element.Sparsevec()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(44))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Dim
+			data31 := unsafe.Pointer(unsafe.SliceData((payload).Indices))
+			pinner.Pin(data31)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len((payload).Indices)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(data31)))
+			data32 := unsafe.Pointer(unsafe.SliceData((payload).Values))
+			pinner.Pin(data32)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len((payload).Values)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(data32)))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_connection_query((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result34), length35, returnArea)
+	var result95 witTypes.Result[DbResult, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		result43 := make([]DbColumn, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(16+8*4))
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			var variant DbColumnType
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+			case 0:
+
+				variant = MakeDbColumnTypeCharacter()
+
+			case 1:
+
+				variant = MakeDbColumnTypeInt2()
+
+			case 2:
+
+				variant = MakeDbColumnTypeInt4()
+
+			case 3:
+
+				variant = MakeDbColumnTypeInt8()
+
+			case 4:
+
+				variant = MakeDbColumnTypeFloat4()
+
+			case 5:
+
+				variant = MakeDbColumnTypeFloat8()
+
+			case 6:
+
+				variant = MakeDbColumnTypeNumeric()
+
+			case 7:
+
+				variant = MakeDbColumnTypeBoolean()
+
+			case 8:
+
+				variant = MakeDbColumnTypeText()
+
+			case 9:
+
+				variant = MakeDbColumnTypeVarchar()
+
+			case 10:
+
+				variant = MakeDbColumnTypeBpchar()
+
+			case 11:
+
+				variant = MakeDbColumnTypeTimestamp()
+
+			case 12:
+
+				variant = MakeDbColumnTypeTimestamptz()
+
+			case 13:
+
+				variant = MakeDbColumnTypeDate()
+
+			case 14:
+
+				variant = MakeDbColumnTypeTime()
+
+			case 15:
+
+				variant = MakeDbColumnTypeTimetz()
+
+			case 16:
+
+				variant = MakeDbColumnTypeInterval()
+
+			case 17:
+
+				variant = MakeDbColumnTypeBytea()
+
+			case 18:
+
+				variant = MakeDbColumnTypeUuid()
+
+			case 19:
+
+				variant = MakeDbColumnTypeXml()
+
+			case 20:
+
+				variant = MakeDbColumnTypeJson()
+
+			case 21:
+
+				variant = MakeDbColumnTypeJsonb()
+
+			case 22:
+
+				variant = MakeDbColumnTypeJsonpath()
+
+			case 23:
+
+				variant = MakeDbColumnTypeInet()
+
+			case 24:
+
+				variant = MakeDbColumnTypeCidr()
+
+			case 25:
+
+				variant = MakeDbColumnTypeMacaddr()
+
+			case 26:
+
+				variant = MakeDbColumnTypeBit()
+
+			case 27:
+
+				variant = MakeDbColumnTypeVarbit()
+
+			case 28:
+
+				variant = MakeDbColumnTypeInt4range()
+
+			case 29:
+
+				variant = MakeDbColumnTypeInt8range()
+
+			case 30:
+
+				variant = MakeDbColumnTypeNumrange()
+
+			case 31:
+
+				variant = MakeDbColumnTypeTsrange()
+
+			case 32:
+
+				variant = MakeDbColumnTypeTstzrange()
+
+			case 33:
+
+				variant = MakeDbColumnTypeDaterange()
+
+			case 34:
+
+				variant = MakeDbColumnTypeMoney()
+
+			case 35:
+
+				variant = MakeDbColumnTypeOid()
+
+			case 36:
+				value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+				variant = MakeDbColumnTypeEnumeration(EnumerationType{value36})
+
+			case 37:
+				value37 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+				result39 := make([]witTypes.Tuple2[string, *LazyDbColumnType], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(3*4))
+					value38 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result39 = append(result39, witTypes.Tuple2[string, *LazyDbColumnType]{value38, LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))))})
+				}
+
+				variant = MakeDbColumnTypeComposite(CompositeType{value37, result39})
+
+			case 38:
+				value40 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+				variant = MakeDbColumnTypeDomain(DomainType{value40, LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))))})
+
+			case 39:
+
+				variant = MakeDbColumnTypeArray(LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))))
+
+			case 40:
+				value41 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+				variant = MakeDbColumnTypeRange(RangeType{value41, LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))))})
+
+			case 41:
+
+				variant = MakeDbColumnTypeVector()
+
+			case 42:
+
+				variant = MakeDbColumnTypeHalfvec()
+
+			case 43:
+
+				variant = MakeDbColumnTypeSparsevec()
+
+			default:
+				panic("unreachable")
+			}
+			value42 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+
+			result43 = append(result43, DbColumn{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), value, variant, value42})
+		}
+
+		result88 := make([]DbRow, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))), index*(2*4))
+			result87 := make([]DbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*56)
+				var variant86 DbValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant86 = MakeDbValueCharacter(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 1:
+
+					variant86 = MakeDbValueInt2(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 2:
+
+					variant86 = MakeDbValueInt4(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 3:
+
+					variant86 = MakeDbValueInt8(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 4:
+
+					variant86 = MakeDbValueFloat4(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 5:
+
+					variant86 = MakeDbValueFloat8(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 6:
+					value44 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueNumeric(value44)
+
+				case 7:
+
+					variant86 = MakeDbValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+				case 8:
+					value45 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueText(value45)
+
+				case 9:
+					value46 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueVarchar(value46)
+
+				case 10:
+					value47 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueBpchar(value47)
+
+				case 11:
+
+					variant86 = MakeDbValueTimestamp(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))}})
+
+				case 12:
+
+					variant86 = MakeDbValueTimestamptz(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 24))})
+
+				case 13:
+
+					variant86 = MakeDbValueDate(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))})
+
+				case 14:
+
+					variant86 = MakeDbValueTime(golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+				case 15:
+
+					variant86 = MakeDbValueTimetz(golem_rdbms_types.Timetz{golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+				case 16:
+
+					variant86 = MakeDbValueInterval(Interval{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), *(*int64)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+				case 17:
+					value48 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueBytea(value48)
+
+				case 18:
+					value49 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueJson(value49)
+
+				case 19:
+					value50 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueJsonb(value50)
+
+				case 20:
+					value51 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueJsonpath(value51)
+
+				case 21:
+					value52 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueXml(value52)
+
+				case 22:
+
+					variant86 = MakeDbValueUuid(golem_rdbms_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+				case 23:
+					var variant53 golem_rdbms_types.IpAddress
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant53 = golem_rdbms_types.MakeIpAddressIpv4(witTypes.Tuple4[uint8, uint8, uint8, uint8]{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 11)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))})
+
+					case 1:
+
+						variant53 = golem_rdbms_types.MakeIpAddressIpv6(witTypes.Tuple8[uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint16]{uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 14)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))})
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueInet(variant53)
+
+				case 24:
+					var variant54 golem_rdbms_types.IpAddress
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant54 = golem_rdbms_types.MakeIpAddressIpv4(witTypes.Tuple4[uint8, uint8, uint8, uint8]{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 11)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))})
+
+					case 1:
+
+						variant54 = golem_rdbms_types.MakeIpAddressIpv6(witTypes.Tuple8[uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint16]{uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 14)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))})
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueCidr(variant54)
+
+				case 25:
+
+					variant86 = MakeDbValueMacaddr(golem_rdbms_types.MacAddress{witTypes.Tuple6[uint8, uint8, uint8, uint8, uint8, uint8]{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 11)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))}})
+
+				case 26:
+					result55 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+						result55 = append(result55, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+					}
+
+					variant86 = MakeDbValueBit(result55)
+
+				case 27:
+					result56 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+						result56 = append(result56, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+					}
+
+					variant86 = MakeDbValueVarbit(result56)
+
+				case 28:
+					var variant57 Int4bound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant57 = MakeInt4boundIncluded(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+
+					case 1:
+
+						variant57 = MakeInt4boundExcluded(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+
+					case 2:
+
+						variant57 = MakeInt4boundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant58 Int4bound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						variant58 = MakeInt4boundIncluded(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+
+					case 1:
+
+						variant58 = MakeInt4boundExcluded(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+
+					case 2:
+
+						variant58 = MakeInt4boundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueInt4range(Int4range{variant57, variant58})
+
+				case 29:
+					var variant59 Int8bound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant59 = MakeInt8boundIncluded(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))
+
+					case 1:
+
+						variant59 = MakeInt8boundExcluded(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))
+
+					case 2:
+
+						variant59 = MakeInt8boundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant60 Int8bound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+					case 0:
+
+						variant60 = MakeInt8boundIncluded(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 1:
+
+						variant60 = MakeInt8boundExcluded(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 2:
+
+						variant60 = MakeInt8boundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueInt8range(Int8range{variant59, variant60})
+
+				case 30:
+					var variant63 Numbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+						value61 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+						variant63 = MakeNumboundIncluded(value61)
+
+					case 1:
+						value62 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+						variant63 = MakeNumboundExcluded(value62)
+
+					case 2:
+
+						variant63 = MakeNumboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant66 Numbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+					case 0:
+						value64 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+
+						variant66 = MakeNumboundIncluded(value64)
+
+					case 1:
+						value65 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+
+						variant66 = MakeNumboundExcluded(value65)
+
+					case 2:
+
+						variant66 = MakeNumboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueNumrange(Numrange{variant63, variant66})
+
+				case 31:
+					var variant67 Tsbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant67 = MakeTsboundIncluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}})
+
+					case 1:
+
+						variant67 = MakeTsboundExcluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}})
+
+					case 2:
+
+						variant67 = MakeTsboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant68 Tsbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 28))) {
+					case 0:
+
+						variant68 = MakeTsboundIncluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 36)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 37))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 41)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 42)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)))}})
+
+					case 1:
+
+						variant68 = MakeTsboundExcluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 36)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 37))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 41)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 42)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)))}})
+
+					case 2:
+
+						variant68 = MakeTsboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueTsrange(Tsrange{variant67, variant68})
+
+				case 32:
+					var variant69 Tstzbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant69 = MakeTstzboundIncluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 28))})
+
+					case 1:
+
+						variant69 = MakeTstzboundExcluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 28))})
+
+					case 2:
+
+						variant69 = MakeTstzboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant70 Tstzbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+					case 0:
+
+						variant70 = MakeTstzboundIncluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 41))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 44)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 45)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 46)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 52))})
+
+					case 1:
+
+						variant70 = MakeTstzboundExcluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 41))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 44)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 45)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 46)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 52))})
+
+					case 2:
+
+						variant70 = MakeTstzboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueTstzrange(Tstzrange{variant69, variant70})
+
+				case 33:
+					var variant71 Datebound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant71 = MakeDateboundIncluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))})
+
+					case 1:
+
+						variant71 = MakeDateboundExcluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))})
+
+					case 2:
+
+						variant71 = MakeDateboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant72 Datebound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20))) {
+					case 0:
+
+						variant72 = MakeDateboundIncluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 28)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 29))))})
+
+					case 1:
+
+						variant72 = MakeDateboundExcluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 28)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 29))))})
+
+					case 2:
+
+						variant72 = MakeDateboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueDaterange(Daterange{variant71, variant72})
+
+				case 34:
+
+					variant86 = MakeDbValueMoney(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 35:
+
+					variant86 = MakeDbValueOid(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 36:
+					value73 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					value74 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+					variant86 = MakeDbValueEnumeration(Enumeration{value73, value74})
+
+				case 37:
+					value75 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					result76 := make([]*LazyDbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*4)
+
+						result76 = append(result76, LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 0))))))
+					}
+
+					variant86 = MakeDbValueComposite(Composite{value75, result76})
+
+				case 38:
+					value77 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueDomain(Domain{value77, LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))))})
+
+				case 39:
+					result78 := make([]*LazyDbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result78 = append(result78, LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 0))))))
+					}
+
+					variant86 = MakeDbValueArray(result78)
+
+				case 40:
+					value79 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					var variant80 ValueBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						variant80 = MakeValueBoundIncluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4)))))))
+
+					case 1:
+
+						variant80 = MakeValueBoundExcluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4)))))))
+
+					case 2:
+
+						variant80 = MakeValueBoundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant81 ValueBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) {
+					case 0:
+
+						variant81 = MakeValueBoundIncluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4)))))))
+
+					case 1:
+
+						variant81 = MakeValueBoundExcluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4)))))))
+
+					case 2:
+
+						variant81 = MakeValueBoundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueRange(Range{value79, ValuesRange{variant80, variant81}})
+
+				case 41:
+
+					variant86 = MakeDbValueNull()
+
+				case 42:
+					value82 := unsafe.Slice((*float32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueVector(value82)
+
+				case 43:
+					value83 := unsafe.Slice((*float32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueHalfvec(value83)
+
+				case 44:
+					value84 := unsafe.Slice((*int32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+					value85 := unsafe.Slice((*float32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+					variant86 = MakeDbValueSparsevec(SparseVec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), value84, value85})
+
+				default:
+					panic("unreachable")
+				}
+
+				result87 = append(result87, variant86)
+			}
+
+			result88 = append(result88, DbRow{result87})
+		}
+
+		result95 = witTypes.Ok[DbResult, Error](DbResult{result43, result88})
+	case 1:
+		var variant94 Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value89 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant94 = MakeErrorConnectionFailure(value89)
+
+		case 1:
+			value90 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant94 = MakeErrorQueryParameterFailure(value90)
+
+		case 2:
+			value91 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant94 = MakeErrorQueryExecutionFailure(value91)
+
+		case 3:
+			value92 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant94 = MakeErrorQueryResponseFailure(value92)
+
+		case 4:
+			value93 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant94 = MakeErrorOther(value93)
+
+		default:
+			panic("unreachable")
+		}
+
+		result95 = witTypes.Err[DbResult, Error](variant94)
+	default:
+		panic("unreachable")
+	}
+	result96 := result95
+	return result96
+
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [method]db-connection.query-stream
+func wasm_import_method_db_connection_query_stream(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbConnection) QueryStream(statement string, params []DbValue) witTypes.Result[*DbResultStream, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice33 := params
+	length35 := uint32(len(slice33))
+	result34 := witRuntime.Allocate(pinner, uintptr(length35*56), 8)
+	for index, element := range slice33 {
+		base := unsafe.Add(result34, index*56)
+
+		switch element.Tag() {
+		case DbValueCharacter:
+			payload := element.Character()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueInt2:
+			payload := element.Int2()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueInt4:
+			payload := element.Int4()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueInt8:
+			payload := element.Int8()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueFloat4:
+			payload := element.Float4()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueFloat8:
+			payload := element.Float8()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueNumeric:
+			payload := element.Numeric()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueBoolean:
+			payload := element.Boolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueText:
+			payload := element.Text()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueVarchar:
+			payload := element.Varchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			utf82 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf82)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf82)))
+
+		case DbValueBpchar:
+			payload := element.Bpchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			utf83 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf83)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf83)))
+
+		case DbValueTimestamp:
+			payload := element.Timestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTimestamptz:
+			payload := element.Timestamptz()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (((payload).Timestamp).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((((payload).Timestamp).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((((payload).Timestamp).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32((((payload).Timestamp).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32((((payload).Timestamp).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Offset
+
+		case DbValueDate:
+			payload := element.Date()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).Day))
+
+		case DbValueTime:
+			payload := element.Time()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Nanosecond)
+
+		case DbValueTimetz:
+			payload := element.Timetz()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32(((payload).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Offset
+
+		case DbValueInterval:
+			payload := element.Interval()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Months
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Days
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Microseconds
+
+		case DbValueBytea:
+			payload := element.Bytea()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		case DbValueJson:
+			payload := element.Json()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			utf84 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf84)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf84)))
+
+		case DbValueJsonb:
+			payload := element.Jsonb()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			utf85 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf85)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf85)))
+
+		case DbValueJsonpath:
+			payload := element.Jsonpath()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			utf86 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf86)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf86)))
+
+		case DbValueXml:
+			payload := element.Xml()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			utf87 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf87)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf87)))
+
+		case DbValueUuid:
+			payload := element.Uuid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).LowBits)
+
+		case DbValueInet:
+			payload := element.Inet()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+			switch payload.Tag() {
+			case golem_rdbms_types.IpAddressIpv4:
+				payload := payload.Ipv4()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).F0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32((payload).F1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).F2))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).F3))
+
+			case golem_rdbms_types.IpAddressIpv6:
+				payload := payload.Ipv6()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 10)) = int16(int32((payload).F0))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 12)) = int16(int32((payload).F1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 14)) = int16(int32((payload).F2))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 16)) = int16(int32((payload).F3))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 18)) = int16(int32((payload).F4))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 20)) = int16(int32((payload).F5))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 22)) = int16(int32((payload).F6))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 24)) = int16(int32((payload).F7))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueCidr:
+			payload := element.Cidr()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+			switch payload.Tag() {
+			case golem_rdbms_types.IpAddressIpv4:
+				payload := payload.Ipv4()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).F0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32((payload).F1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).F2))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).F3))
+
+			case golem_rdbms_types.IpAddressIpv6:
+				payload := payload.Ipv6()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 10)) = int16(int32((payload).F0))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 12)) = int16(int32((payload).F1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 14)) = int16(int32((payload).F2))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 16)) = int16(int32((payload).F3))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 18)) = int16(int32((payload).F4))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 20)) = int16(int32((payload).F5))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 22)) = int16(int32((payload).F6))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 24)) = int16(int32((payload).F7))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueMacaddr:
+			payload := element.Macaddr()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(((payload).Octets).F0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32(((payload).Octets).F1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32(((payload).Octets).F2))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32(((payload).Octets).F3))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Octets).F4))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Octets).F5))
+
+		case DbValueBit:
+			payload := element.Bit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			slice := payload
+			length := uint32(len(slice))
+			result9 := witRuntime.Allocate(pinner, uintptr(length*1), 1)
+			for index, element := range slice {
+				base := unsafe.Add(result9, index*1)
+				var result8 int32
+				if element {
+					result8 = 1
+				} else {
+					result8 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result8)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result9)))
+
+		case DbValueVarbit:
+			payload := element.Varbit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			slice11 := payload
+			length13 := uint32(len(slice11))
+			result12 := witRuntime.Allocate(pinner, uintptr(length13*1), 1)
+			for index, element := range slice11 {
+				base := unsafe.Add(result12, index*1)
+				var result10 int32
+				if element {
+					result10 = 1
+				} else {
+					result10 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result10)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length13)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result12)))
+
+		case DbValueInt4range:
+			payload := element.Int4range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+			switch (payload).Start.Tag() {
+			case Int4boundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			case Int4boundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			case Int4boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case Int4boundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			case Int4boundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			case Int4boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueInt8range:
+			payload := element.Int8range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+			switch (payload).Start.Tag() {
+			case Int8boundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			case Int8boundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			case Int8boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case Int8boundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+			case Int8boundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+			case Int8boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueNumrange:
+			payload := element.Numrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+
+			switch (payload).Start.Tag() {
+			case NumboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				utf814 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf814)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf814)))
+
+			case NumboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				utf815 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf815)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf815)))
+
+			case NumboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case NumboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+				utf816 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf816)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(utf816)))
+
+			case NumboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				utf817 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf817)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(utf817)))
+
+			case NumboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueTsrange:
+			payload := element.Tsrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+
+			switch (payload).Start.Tag() {
+			case TsboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case TsboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 36)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 37)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 42)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 36)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 37)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 42)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueTstzrange:
+			payload := element.Tstzrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+
+			switch (payload).Start.Tag() {
+			case TstzboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 28)) = (payload).Offset
+
+			case TstzboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 28)) = (payload).Offset
+
+			case TstzboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case TstzboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 44)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 45)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 46)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 52)) = (payload).Offset
+
+			case TstzboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 44)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 45)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 46)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 52)) = (payload).Offset
+
+			case TstzboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueDaterange:
+			payload := element.Daterange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+			switch (payload).Start.Tag() {
+			case DateboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((payload).Day))
+
+			case DateboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((payload).Day))
+
+			case DateboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case DateboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 29)) = int8(int32((payload).Day))
+
+			case DateboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 29)) = int8(int32((payload).Day))
+
+			case DateboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueMoney:
+			payload := element.Money()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueOid:
+			payload := element.Oid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueEnumeration:
+			payload := element.Enumeration()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36))
+			utf818 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf818)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf818)))
+			utf819 := unsafe.Pointer(unsafe.StringData((payload).Value))
+			pinner.Pin(utf819)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Value)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf819)))
+
+		case DbValueComposite:
+			payload := element.Composite()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(37))
+			utf820 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf820)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf820)))
+			slice21 := (payload).Values
+			length23 := uint32(len(slice21))
+			result22 := witRuntime.Allocate(pinner, uintptr(length23*4), 4)
+			for index, element := range slice21 {
+				base := unsafe.Add(result22, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).TakeHandle()
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length23)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result22)))
+
+		case DbValueDomain:
+			payload := element.Domain()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(38))
+			utf824 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf824)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf824)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = ((payload).Value).TakeHandle()
+
+		case DbValueArray:
+			payload := element.Array()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(39))
+			slice25 := payload
+			length27 := uint32(len(slice25))
+			result26 := witRuntime.Allocate(pinner, uintptr(length27*4), 4)
+			for index, element := range slice25 {
+				base := unsafe.Add(result26, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).TakeHandle()
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length27)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result26)))
+
+		case DbValueRange:
+			payload := element.Range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(40))
+			utf828 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf828)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf828)))
+
+			switch ((payload).Value).Start.Tag() {
+			case ValueBoundIncluded:
+				payload := ((payload).Value).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundExcluded:
+				payload := ((payload).Value).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch ((payload).Value).End.Tag() {
+			case ValueBoundIncluded:
+				payload := ((payload).Value).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundExcluded:
+				payload := ((payload).Value).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(41))
+
+		case DbValueVector:
+			payload := element.Vector()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(42))
+			data29 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data29)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data29)))
+
+		case DbValueHalfvec:
+			payload := element.Halfvec()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(43))
+			data30 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data30)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data30)))
+
+		case DbValueSparsevec:
+			payload := element.Sparsevec()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(44))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Dim
+			data31 := unsafe.Pointer(unsafe.SliceData((payload).Indices))
+			pinner.Pin(data31)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len((payload).Indices)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(data31)))
+			data32 := unsafe.Pointer(unsafe.SliceData((payload).Values))
+			pinner.Pin(data32)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len((payload).Values)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(data32)))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_connection_query_stream((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result34), length35, returnArea)
+	var result40 witTypes.Result[*DbResultStream, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result40 = witTypes.Ok[*DbResultStream, Error](DbResultStreamFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value36)
+
+		case 2:
+			value37 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value37)
+
+		case 3:
+			value38 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value38)
+
+		case 4:
+			value39 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value39)
+
+		default:
+			panic("unreachable")
+		}
+
+		result40 = witTypes.Err[*DbResultStream, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result41 := result40
+	return result41
+
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [method]db-connection.execute
+func wasm_import_method_db_connection_execute(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbConnection) Execute(statement string, params []DbValue) witTypes.Result[uint64, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (16 + 2*4), 8))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice33 := params
+	length35 := uint32(len(slice33))
+	result34 := witRuntime.Allocate(pinner, uintptr(length35*56), 8)
+	for index, element := range slice33 {
+		base := unsafe.Add(result34, index*56)
+
+		switch element.Tag() {
+		case DbValueCharacter:
+			payload := element.Character()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueInt2:
+			payload := element.Int2()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueInt4:
+			payload := element.Int4()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueInt8:
+			payload := element.Int8()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueFloat4:
+			payload := element.Float4()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueFloat8:
+			payload := element.Float8()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueNumeric:
+			payload := element.Numeric()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueBoolean:
+			payload := element.Boolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueText:
+			payload := element.Text()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueVarchar:
+			payload := element.Varchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			utf82 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf82)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf82)))
+
+		case DbValueBpchar:
+			payload := element.Bpchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			utf83 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf83)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf83)))
+
+		case DbValueTimestamp:
+			payload := element.Timestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTimestamptz:
+			payload := element.Timestamptz()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (((payload).Timestamp).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((((payload).Timestamp).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((((payload).Timestamp).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32((((payload).Timestamp).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32((((payload).Timestamp).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Offset
+
+		case DbValueDate:
+			payload := element.Date()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).Day))
+
+		case DbValueTime:
+			payload := element.Time()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Nanosecond)
+
+		case DbValueTimetz:
+			payload := element.Timetz()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32(((payload).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Offset
+
+		case DbValueInterval:
+			payload := element.Interval()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Months
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Days
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Microseconds
+
+		case DbValueBytea:
+			payload := element.Bytea()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		case DbValueJson:
+			payload := element.Json()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			utf84 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf84)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf84)))
+
+		case DbValueJsonb:
+			payload := element.Jsonb()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			utf85 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf85)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf85)))
+
+		case DbValueJsonpath:
+			payload := element.Jsonpath()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			utf86 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf86)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf86)))
+
+		case DbValueXml:
+			payload := element.Xml()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			utf87 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf87)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf87)))
+
+		case DbValueUuid:
+			payload := element.Uuid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).LowBits)
+
+		case DbValueInet:
+			payload := element.Inet()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+			switch payload.Tag() {
+			case golem_rdbms_types.IpAddressIpv4:
+				payload := payload.Ipv4()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).F0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32((payload).F1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).F2))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).F3))
+
+			case golem_rdbms_types.IpAddressIpv6:
+				payload := payload.Ipv6()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 10)) = int16(int32((payload).F0))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 12)) = int16(int32((payload).F1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 14)) = int16(int32((payload).F2))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 16)) = int16(int32((payload).F3))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 18)) = int16(int32((payload).F4))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 20)) = int16(int32((payload).F5))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 22)) = int16(int32((payload).F6))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 24)) = int16(int32((payload).F7))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueCidr:
+			payload := element.Cidr()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+			switch payload.Tag() {
+			case golem_rdbms_types.IpAddressIpv4:
+				payload := payload.Ipv4()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).F0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32((payload).F1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).F2))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).F3))
+
+			case golem_rdbms_types.IpAddressIpv6:
+				payload := payload.Ipv6()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 10)) = int16(int32((payload).F0))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 12)) = int16(int32((payload).F1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 14)) = int16(int32((payload).F2))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 16)) = int16(int32((payload).F3))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 18)) = int16(int32((payload).F4))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 20)) = int16(int32((payload).F5))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 22)) = int16(int32((payload).F6))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 24)) = int16(int32((payload).F7))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueMacaddr:
+			payload := element.Macaddr()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(((payload).Octets).F0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32(((payload).Octets).F1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32(((payload).Octets).F2))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32(((payload).Octets).F3))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Octets).F4))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Octets).F5))
+
+		case DbValueBit:
+			payload := element.Bit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			slice := payload
+			length := uint32(len(slice))
+			result9 := witRuntime.Allocate(pinner, uintptr(length*1), 1)
+			for index, element := range slice {
+				base := unsafe.Add(result9, index*1)
+				var result8 int32
+				if element {
+					result8 = 1
+				} else {
+					result8 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result8)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result9)))
+
+		case DbValueVarbit:
+			payload := element.Varbit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			slice11 := payload
+			length13 := uint32(len(slice11))
+			result12 := witRuntime.Allocate(pinner, uintptr(length13*1), 1)
+			for index, element := range slice11 {
+				base := unsafe.Add(result12, index*1)
+				var result10 int32
+				if element {
+					result10 = 1
+				} else {
+					result10 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result10)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length13)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result12)))
+
+		case DbValueInt4range:
+			payload := element.Int4range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+			switch (payload).Start.Tag() {
+			case Int4boundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			case Int4boundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			case Int4boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case Int4boundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			case Int4boundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			case Int4boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueInt8range:
+			payload := element.Int8range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+			switch (payload).Start.Tag() {
+			case Int8boundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			case Int8boundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			case Int8boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case Int8boundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+			case Int8boundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+			case Int8boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueNumrange:
+			payload := element.Numrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+
+			switch (payload).Start.Tag() {
+			case NumboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				utf814 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf814)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf814)))
+
+			case NumboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				utf815 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf815)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf815)))
+
+			case NumboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case NumboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+				utf816 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf816)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(utf816)))
+
+			case NumboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				utf817 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf817)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(utf817)))
+
+			case NumboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueTsrange:
+			payload := element.Tsrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+
+			switch (payload).Start.Tag() {
+			case TsboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case TsboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 36)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 37)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 42)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 36)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 37)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 42)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueTstzrange:
+			payload := element.Tstzrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+
+			switch (payload).Start.Tag() {
+			case TstzboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 28)) = (payload).Offset
+
+			case TstzboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 28)) = (payload).Offset
+
+			case TstzboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case TstzboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 44)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 45)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 46)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 52)) = (payload).Offset
+
+			case TstzboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 44)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 45)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 46)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 52)) = (payload).Offset
+
+			case TstzboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueDaterange:
+			payload := element.Daterange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+			switch (payload).Start.Tag() {
+			case DateboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((payload).Day))
+
+			case DateboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((payload).Day))
+
+			case DateboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case DateboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 29)) = int8(int32((payload).Day))
+
+			case DateboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 29)) = int8(int32((payload).Day))
+
+			case DateboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueMoney:
+			payload := element.Money()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueOid:
+			payload := element.Oid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueEnumeration:
+			payload := element.Enumeration()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36))
+			utf818 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf818)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf818)))
+			utf819 := unsafe.Pointer(unsafe.StringData((payload).Value))
+			pinner.Pin(utf819)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Value)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf819)))
+
+		case DbValueComposite:
+			payload := element.Composite()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(37))
+			utf820 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf820)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf820)))
+			slice21 := (payload).Values
+			length23 := uint32(len(slice21))
+			result22 := witRuntime.Allocate(pinner, uintptr(length23*4), 4)
+			for index, element := range slice21 {
+				base := unsafe.Add(result22, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).TakeHandle()
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length23)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result22)))
+
+		case DbValueDomain:
+			payload := element.Domain()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(38))
+			utf824 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf824)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf824)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = ((payload).Value).TakeHandle()
+
+		case DbValueArray:
+			payload := element.Array()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(39))
+			slice25 := payload
+			length27 := uint32(len(slice25))
+			result26 := witRuntime.Allocate(pinner, uintptr(length27*4), 4)
+			for index, element := range slice25 {
+				base := unsafe.Add(result26, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).TakeHandle()
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length27)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result26)))
+
+		case DbValueRange:
+			payload := element.Range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(40))
+			utf828 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf828)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf828)))
+
+			switch ((payload).Value).Start.Tag() {
+			case ValueBoundIncluded:
+				payload := ((payload).Value).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundExcluded:
+				payload := ((payload).Value).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch ((payload).Value).End.Tag() {
+			case ValueBoundIncluded:
+				payload := ((payload).Value).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundExcluded:
+				payload := ((payload).Value).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(41))
+
+		case DbValueVector:
+			payload := element.Vector()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(42))
+			data29 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data29)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data29)))
+
+		case DbValueHalfvec:
+			payload := element.Halfvec()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(43))
+			data30 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data30)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data30)))
+
+		case DbValueSparsevec:
+			payload := element.Sparsevec()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(44))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Dim
+			data31 := unsafe.Pointer(unsafe.SliceData((payload).Indices))
+			pinner.Pin(data31)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len((payload).Indices)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(data31)))
+			data32 := unsafe.Pointer(unsafe.SliceData((payload).Values))
+			pinner.Pin(data32)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len((payload).Values)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(data32)))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_connection_execute((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result34), length35, returnArea)
+	var result40 witTypes.Result[uint64, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result40 = witTypes.Ok[uint64, Error](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryParameterFailure(value36)
+
+		case 2:
+			value37 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryExecutionFailure(value37)
+
+		case 3:
+			value38 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryResponseFailure(value38)
+
+		case 4:
+			value39 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorOther(value39)
+
+		default:
+			panic("unreachable")
+		}
+
+		result40 = witTypes.Err[uint64, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result41 := result40
+	return result41
+
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [method]db-connection.begin-transaction
+func wasm_import_method_db_connection_begin_transaction(arg0 int32, arg1 uintptr)
+
+func (self *DbConnection) BeginTransaction() witTypes.Result[*DbTransaction, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	wasm_import_method_db_connection_begin_transaction((self).Handle(), returnArea)
+	var result witTypes.Result[*DbTransaction, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[*DbTransaction, Error](DbTransactionFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value0)
+
+		case 2:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value1)
+
+		case 3:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value2)
+
+		case 4:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value3)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[*DbTransaction, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result4 := result
+	return result4
+
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [method]db-transaction.query
+func wasm_import_method_db_transaction_query(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbTransaction) Query(statement string, params []DbValue) witTypes.Result[DbResult, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice33 := params
+	length35 := uint32(len(slice33))
+	result34 := witRuntime.Allocate(pinner, uintptr(length35*56), 8)
+	for index, element := range slice33 {
+		base := unsafe.Add(result34, index*56)
+
+		switch element.Tag() {
+		case DbValueCharacter:
+			payload := element.Character()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueInt2:
+			payload := element.Int2()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueInt4:
+			payload := element.Int4()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueInt8:
+			payload := element.Int8()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueFloat4:
+			payload := element.Float4()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueFloat8:
+			payload := element.Float8()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueNumeric:
+			payload := element.Numeric()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueBoolean:
+			payload := element.Boolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueText:
+			payload := element.Text()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueVarchar:
+			payload := element.Varchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			utf82 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf82)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf82)))
+
+		case DbValueBpchar:
+			payload := element.Bpchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			utf83 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf83)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf83)))
+
+		case DbValueTimestamp:
+			payload := element.Timestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTimestamptz:
+			payload := element.Timestamptz()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (((payload).Timestamp).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((((payload).Timestamp).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((((payload).Timestamp).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32((((payload).Timestamp).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32((((payload).Timestamp).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Offset
+
+		case DbValueDate:
+			payload := element.Date()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).Day))
+
+		case DbValueTime:
+			payload := element.Time()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Nanosecond)
+
+		case DbValueTimetz:
+			payload := element.Timetz()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32(((payload).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Offset
+
+		case DbValueInterval:
+			payload := element.Interval()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Months
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Days
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Microseconds
+
+		case DbValueBytea:
+			payload := element.Bytea()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		case DbValueJson:
+			payload := element.Json()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			utf84 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf84)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf84)))
+
+		case DbValueJsonb:
+			payload := element.Jsonb()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			utf85 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf85)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf85)))
+
+		case DbValueJsonpath:
+			payload := element.Jsonpath()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			utf86 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf86)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf86)))
+
+		case DbValueXml:
+			payload := element.Xml()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			utf87 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf87)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf87)))
+
+		case DbValueUuid:
+			payload := element.Uuid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).LowBits)
+
+		case DbValueInet:
+			payload := element.Inet()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+			switch payload.Tag() {
+			case golem_rdbms_types.IpAddressIpv4:
+				payload := payload.Ipv4()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).F0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32((payload).F1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).F2))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).F3))
+
+			case golem_rdbms_types.IpAddressIpv6:
+				payload := payload.Ipv6()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 10)) = int16(int32((payload).F0))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 12)) = int16(int32((payload).F1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 14)) = int16(int32((payload).F2))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 16)) = int16(int32((payload).F3))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 18)) = int16(int32((payload).F4))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 20)) = int16(int32((payload).F5))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 22)) = int16(int32((payload).F6))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 24)) = int16(int32((payload).F7))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueCidr:
+			payload := element.Cidr()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+			switch payload.Tag() {
+			case golem_rdbms_types.IpAddressIpv4:
+				payload := payload.Ipv4()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).F0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32((payload).F1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).F2))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).F3))
+
+			case golem_rdbms_types.IpAddressIpv6:
+				payload := payload.Ipv6()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 10)) = int16(int32((payload).F0))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 12)) = int16(int32((payload).F1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 14)) = int16(int32((payload).F2))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 16)) = int16(int32((payload).F3))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 18)) = int16(int32((payload).F4))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 20)) = int16(int32((payload).F5))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 22)) = int16(int32((payload).F6))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 24)) = int16(int32((payload).F7))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueMacaddr:
+			payload := element.Macaddr()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(((payload).Octets).F0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32(((payload).Octets).F1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32(((payload).Octets).F2))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32(((payload).Octets).F3))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Octets).F4))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Octets).F5))
+
+		case DbValueBit:
+			payload := element.Bit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			slice := payload
+			length := uint32(len(slice))
+			result9 := witRuntime.Allocate(pinner, uintptr(length*1), 1)
+			for index, element := range slice {
+				base := unsafe.Add(result9, index*1)
+				var result8 int32
+				if element {
+					result8 = 1
+				} else {
+					result8 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result8)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result9)))
+
+		case DbValueVarbit:
+			payload := element.Varbit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			slice11 := payload
+			length13 := uint32(len(slice11))
+			result12 := witRuntime.Allocate(pinner, uintptr(length13*1), 1)
+			for index, element := range slice11 {
+				base := unsafe.Add(result12, index*1)
+				var result10 int32
+				if element {
+					result10 = 1
+				} else {
+					result10 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result10)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length13)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result12)))
+
+		case DbValueInt4range:
+			payload := element.Int4range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+			switch (payload).Start.Tag() {
+			case Int4boundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			case Int4boundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			case Int4boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case Int4boundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			case Int4boundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			case Int4boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueInt8range:
+			payload := element.Int8range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+			switch (payload).Start.Tag() {
+			case Int8boundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			case Int8boundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			case Int8boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case Int8boundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+			case Int8boundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+			case Int8boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueNumrange:
+			payload := element.Numrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+
+			switch (payload).Start.Tag() {
+			case NumboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				utf814 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf814)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf814)))
+
+			case NumboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				utf815 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf815)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf815)))
+
+			case NumboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case NumboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+				utf816 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf816)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(utf816)))
+
+			case NumboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				utf817 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf817)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(utf817)))
+
+			case NumboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueTsrange:
+			payload := element.Tsrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+
+			switch (payload).Start.Tag() {
+			case TsboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case TsboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 36)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 37)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 42)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 36)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 37)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 42)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueTstzrange:
+			payload := element.Tstzrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+
+			switch (payload).Start.Tag() {
+			case TstzboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 28)) = (payload).Offset
+
+			case TstzboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 28)) = (payload).Offset
+
+			case TstzboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case TstzboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 44)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 45)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 46)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 52)) = (payload).Offset
+
+			case TstzboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 44)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 45)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 46)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 52)) = (payload).Offset
+
+			case TstzboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueDaterange:
+			payload := element.Daterange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+			switch (payload).Start.Tag() {
+			case DateboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((payload).Day))
+
+			case DateboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((payload).Day))
+
+			case DateboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case DateboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 29)) = int8(int32((payload).Day))
+
+			case DateboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 29)) = int8(int32((payload).Day))
+
+			case DateboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueMoney:
+			payload := element.Money()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueOid:
+			payload := element.Oid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueEnumeration:
+			payload := element.Enumeration()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36))
+			utf818 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf818)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf818)))
+			utf819 := unsafe.Pointer(unsafe.StringData((payload).Value))
+			pinner.Pin(utf819)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Value)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf819)))
+
+		case DbValueComposite:
+			payload := element.Composite()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(37))
+			utf820 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf820)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf820)))
+			slice21 := (payload).Values
+			length23 := uint32(len(slice21))
+			result22 := witRuntime.Allocate(pinner, uintptr(length23*4), 4)
+			for index, element := range slice21 {
+				base := unsafe.Add(result22, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).TakeHandle()
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length23)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result22)))
+
+		case DbValueDomain:
+			payload := element.Domain()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(38))
+			utf824 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf824)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf824)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = ((payload).Value).TakeHandle()
+
+		case DbValueArray:
+			payload := element.Array()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(39))
+			slice25 := payload
+			length27 := uint32(len(slice25))
+			result26 := witRuntime.Allocate(pinner, uintptr(length27*4), 4)
+			for index, element := range slice25 {
+				base := unsafe.Add(result26, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).TakeHandle()
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length27)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result26)))
+
+		case DbValueRange:
+			payload := element.Range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(40))
+			utf828 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf828)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf828)))
+
+			switch ((payload).Value).Start.Tag() {
+			case ValueBoundIncluded:
+				payload := ((payload).Value).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundExcluded:
+				payload := ((payload).Value).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch ((payload).Value).End.Tag() {
+			case ValueBoundIncluded:
+				payload := ((payload).Value).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundExcluded:
+				payload := ((payload).Value).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(41))
+
+		case DbValueVector:
+			payload := element.Vector()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(42))
+			data29 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data29)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data29)))
+
+		case DbValueHalfvec:
+			payload := element.Halfvec()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(43))
+			data30 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data30)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data30)))
+
+		case DbValueSparsevec:
+			payload := element.Sparsevec()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(44))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Dim
+			data31 := unsafe.Pointer(unsafe.SliceData((payload).Indices))
+			pinner.Pin(data31)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len((payload).Indices)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(data31)))
+			data32 := unsafe.Pointer(unsafe.SliceData((payload).Values))
+			pinner.Pin(data32)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len((payload).Values)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(data32)))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_transaction_query((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result34), length35, returnArea)
+	var result95 witTypes.Result[DbResult, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		result43 := make([]DbColumn, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(16+8*4))
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+			var variant DbColumnType
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+			case 0:
+
+				variant = MakeDbColumnTypeCharacter()
+
+			case 1:
+
+				variant = MakeDbColumnTypeInt2()
+
+			case 2:
+
+				variant = MakeDbColumnTypeInt4()
+
+			case 3:
+
+				variant = MakeDbColumnTypeInt8()
+
+			case 4:
+
+				variant = MakeDbColumnTypeFloat4()
+
+			case 5:
+
+				variant = MakeDbColumnTypeFloat8()
+
+			case 6:
+
+				variant = MakeDbColumnTypeNumeric()
+
+			case 7:
+
+				variant = MakeDbColumnTypeBoolean()
+
+			case 8:
+
+				variant = MakeDbColumnTypeText()
+
+			case 9:
+
+				variant = MakeDbColumnTypeVarchar()
+
+			case 10:
+
+				variant = MakeDbColumnTypeBpchar()
+
+			case 11:
+
+				variant = MakeDbColumnTypeTimestamp()
+
+			case 12:
+
+				variant = MakeDbColumnTypeTimestamptz()
+
+			case 13:
+
+				variant = MakeDbColumnTypeDate()
+
+			case 14:
+
+				variant = MakeDbColumnTypeTime()
+
+			case 15:
+
+				variant = MakeDbColumnTypeTimetz()
+
+			case 16:
+
+				variant = MakeDbColumnTypeInterval()
+
+			case 17:
+
+				variant = MakeDbColumnTypeBytea()
+
+			case 18:
+
+				variant = MakeDbColumnTypeUuid()
+
+			case 19:
+
+				variant = MakeDbColumnTypeXml()
+
+			case 20:
+
+				variant = MakeDbColumnTypeJson()
+
+			case 21:
+
+				variant = MakeDbColumnTypeJsonb()
+
+			case 22:
+
+				variant = MakeDbColumnTypeJsonpath()
+
+			case 23:
+
+				variant = MakeDbColumnTypeInet()
+
+			case 24:
+
+				variant = MakeDbColumnTypeCidr()
+
+			case 25:
+
+				variant = MakeDbColumnTypeMacaddr()
+
+			case 26:
+
+				variant = MakeDbColumnTypeBit()
+
+			case 27:
+
+				variant = MakeDbColumnTypeVarbit()
+
+			case 28:
+
+				variant = MakeDbColumnTypeInt4range()
+
+			case 29:
+
+				variant = MakeDbColumnTypeInt8range()
+
+			case 30:
+
+				variant = MakeDbColumnTypeNumrange()
+
+			case 31:
+
+				variant = MakeDbColumnTypeTsrange()
+
+			case 32:
+
+				variant = MakeDbColumnTypeTstzrange()
+
+			case 33:
+
+				variant = MakeDbColumnTypeDaterange()
+
+			case 34:
+
+				variant = MakeDbColumnTypeMoney()
+
+			case 35:
+
+				variant = MakeDbColumnTypeOid()
+
+			case 36:
+				value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+				variant = MakeDbColumnTypeEnumeration(EnumerationType{value36})
+
+			case 37:
+				value37 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+				result39 := make([]witTypes.Tuple2[string, *LazyDbColumnType], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))), index*(3*4))
+					value38 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+					result39 = append(result39, witTypes.Tuple2[string, *LazyDbColumnType]{value38, LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))))))})
+				}
+
+				variant = MakeDbColumnTypeComposite(CompositeType{value37, result39})
+
+			case 38:
+				value40 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+				variant = MakeDbColumnTypeDomain(DomainType{value40, LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))))})
+
+			case 39:
+
+				variant = MakeDbColumnTypeArray(LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))))
+
+			case 40:
+				value41 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+				variant = MakeDbColumnTypeRange(RangeType{value41, LazyDbColumnTypeFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))))})
+
+			case 41:
+
+				variant = MakeDbColumnTypeVector()
+
+			case 42:
+
+				variant = MakeDbColumnTypeHalfvec()
+
+			case 43:
+
+				variant = MakeDbColumnTypeSparsevec()
+
+			default:
+				panic("unreachable")
+			}
+			value42 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))))
+
+			result43 = append(result43, DbColumn{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), value, variant, value42})
+		}
+
+		result88 := make([]DbRow, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))), index*(2*4))
+			result87 := make([]DbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))); index++ {
+				base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)))), index*56)
+				var variant86 DbValue
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+				case 0:
+
+					variant86 = MakeDbValueCharacter(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 1:
+
+					variant86 = MakeDbValueInt2(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+				case 2:
+
+					variant86 = MakeDbValueInt4(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 3:
+
+					variant86 = MakeDbValueInt8(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 4:
+
+					variant86 = MakeDbValueFloat4(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 5:
+
+					variant86 = MakeDbValueFloat8(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 6:
+					value44 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueNumeric(value44)
+
+				case 7:
+
+					variant86 = MakeDbValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+				case 8:
+					value45 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueText(value45)
+
+				case 9:
+					value46 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueVarchar(value46)
+
+				case 10:
+					value47 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueBpchar(value47)
+
+				case 11:
+
+					variant86 = MakeDbValueTimestamp(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))}})
+
+				case 12:
+
+					variant86 = MakeDbValueTimestamptz(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 24))})
+
+				case 13:
+
+					variant86 = MakeDbValueDate(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))})
+
+				case 14:
+
+					variant86 = MakeDbValueTime(golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))})
+
+				case 15:
+
+					variant86 = MakeDbValueTimetz(golem_rdbms_types.Timetz{golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+				case 16:
+
+					variant86 = MakeDbValueInterval(Interval{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), *(*int64)(unsafe.Add(unsafe.Pointer(base), 16))})
+
+				case 17:
+					value48 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueBytea(value48)
+
+				case 18:
+					value49 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueJson(value49)
+
+				case 19:
+					value50 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueJsonb(value50)
+
+				case 20:
+					value51 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueJsonpath(value51)
+
+				case 21:
+					value52 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueXml(value52)
+
+				case 22:
+
+					variant86 = MakeDbValueUuid(golem_rdbms_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+				case 23:
+					var variant53 golem_rdbms_types.IpAddress
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant53 = golem_rdbms_types.MakeIpAddressIpv4(witTypes.Tuple4[uint8, uint8, uint8, uint8]{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 11)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))})
+
+					case 1:
+
+						variant53 = golem_rdbms_types.MakeIpAddressIpv6(witTypes.Tuple8[uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint16]{uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 14)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))})
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueInet(variant53)
+
+				case 24:
+					var variant54 golem_rdbms_types.IpAddress
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant54 = golem_rdbms_types.MakeIpAddressIpv4(witTypes.Tuple4[uint8, uint8, uint8, uint8]{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 11)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))})
+
+					case 1:
+
+						variant54 = golem_rdbms_types.MakeIpAddressIpv6(witTypes.Tuple8[uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint16]{uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 14)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 18)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))})
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueCidr(variant54)
+
+				case 25:
+
+					variant86 = MakeDbValueMacaddr(golem_rdbms_types.MacAddress{witTypes.Tuple6[uint8, uint8, uint8, uint8, uint8, uint8]{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 9)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 10)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 11)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 13))))}})
+
+				case 26:
+					result55 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+						result55 = append(result55, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+					}
+
+					variant86 = MakeDbValueBit(result55)
+
+				case 27:
+					result56 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+						result56 = append(result56, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+					}
+
+					variant86 = MakeDbValueVarbit(result56)
+
+				case 28:
+					var variant57 Int4bound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant57 = MakeInt4boundIncluded(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+
+					case 1:
+
+						variant57 = MakeInt4boundExcluded(*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+
+					case 2:
+
+						variant57 = MakeInt4boundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant58 Int4bound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) {
+					case 0:
+
+						variant58 = MakeInt4boundIncluded(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+
+					case 1:
+
+						variant58 = MakeInt4boundExcluded(*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)))
+
+					case 2:
+
+						variant58 = MakeInt4boundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueInt4range(Int4range{variant57, variant58})
+
+				case 29:
+					var variant59 Int8bound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant59 = MakeInt8boundIncluded(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))
+
+					case 1:
+
+						variant59 = MakeInt8boundExcluded(*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)))
+
+					case 2:
+
+						variant59 = MakeInt8boundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant60 Int8bound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) {
+					case 0:
+
+						variant60 = MakeInt8boundIncluded(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 1:
+
+						variant60 = MakeInt8boundExcluded(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))
+
+					case 2:
+
+						variant60 = MakeInt8boundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueInt8range(Int8range{variant59, variant60})
+
+				case 30:
+					var variant63 Numbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+						value61 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+						variant63 = MakeNumboundIncluded(value61)
+
+					case 1:
+						value62 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+
+						variant63 = MakeNumboundExcluded(value62)
+
+					case 2:
+
+						variant63 = MakeNumboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant66 Numbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) {
+					case 0:
+						value64 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+
+						variant66 = MakeNumboundIncluded(value64)
+
+					case 1:
+						value65 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))))
+
+						variant66 = MakeNumboundExcluded(value65)
+
+					case 2:
+
+						variant66 = MakeNumboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueNumrange(Numrange{variant63, variant66})
+
+				case 31:
+					var variant67 Tsbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant67 = MakeTsboundIncluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}})
+
+					case 1:
+
+						variant67 = MakeTsboundExcluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}})
+
+					case 2:
+
+						variant67 = MakeTsboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant68 Tsbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 28))) {
+					case 0:
+
+						variant68 = MakeTsboundIncluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 36)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 37))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 41)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 42)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)))}})
+
+					case 1:
+
+						variant68 = MakeTsboundExcluded(golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 36)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 37))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 41)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 42)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)))}})
+
+					case 2:
+
+						variant68 = MakeTsboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueTsrange(Tsrange{variant67, variant68})
+
+				case 32:
+					var variant69 Tstzbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant69 = MakeTstzboundIncluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 28))})
+
+					case 1:
+
+						variant69 = MakeTstzboundExcluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 21)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 22)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 28))})
+
+					case 2:
+
+						variant69 = MakeTstzboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant70 Tstzbound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) {
+					case 0:
+
+						variant70 = MakeTstzboundIncluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 41))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 44)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 45)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 46)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 52))})
+
+					case 1:
+
+						variant70 = MakeTstzboundExcluded(golem_rdbms_types.Timestamptz{golem_rdbms_types.Timestamp{golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 41))))}, golem_rdbms_types.Time{uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 44)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 45)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 46)))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)))}}, *(*int32)(unsafe.Add(unsafe.Pointer(base), 52))})
+
+					case 2:
+
+						variant70 = MakeTstzboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueTstzrange(Tstzrange{variant69, variant70})
+
+				case 33:
+					var variant71 Datebound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+					case 0:
+
+						variant71 = MakeDateboundIncluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))})
+
+					case 1:
+
+						variant71 = MakeDateboundExcluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 17))))})
+
+					case 2:
+
+						variant71 = MakeDateboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant72 Datebound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 20))) {
+					case 0:
+
+						variant72 = MakeDateboundIncluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 28)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 29))))})
+
+					case 1:
+
+						variant72 = MakeDateboundExcluded(golem_rdbms_types.Date{*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 28)))), uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 29))))})
+
+					case 2:
+
+						variant72 = MakeDateboundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueDaterange(Daterange{variant71, variant72})
+
+				case 34:
+
+					variant86 = MakeDbValueMoney(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+				case 35:
+
+					variant86 = MakeDbValueOid(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+				case 36:
+					value73 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					value74 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+
+					variant86 = MakeDbValueEnumeration(Enumeration{value73, value74})
+
+				case 37:
+					value75 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					result76 := make([]*LazyDbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))), index*4)
+
+						result76 = append(result76, LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 0))))))
+					}
+
+					variant86 = MakeDbValueComposite(Composite{value75, result76})
+
+				case 38:
+					value77 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueDomain(Domain{value77, LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))))})
+
+				case 39:
+					result78 := make([]*LazyDbValue, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+						base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+						result78 = append(result78, LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 0))))))
+					}
+
+					variant86 = MakeDbValueArray(result78)
+
+				case 40:
+					value79 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+					var variant80 ValueBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+					case 0:
+
+						variant80 = MakeValueBoundIncluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4)))))))
+
+					case 1:
+
+						variant80 = MakeValueBoundExcluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4)))))))
+
+					case 2:
+
+						variant80 = MakeValueBoundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+					var variant81 ValueBound
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) {
+					case 0:
+
+						variant81 = MakeValueBoundIncluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4)))))))
+
+					case 1:
+
+						variant81 = MakeValueBoundExcluded(LazyDbValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4)))))))
+
+					case 2:
+
+						variant81 = MakeValueBoundUnbounded()
+
+					default:
+						panic("unreachable")
+					}
+
+					variant86 = MakeDbValueRange(Range{value79, ValuesRange{variant80, variant81}})
+
+				case 41:
+
+					variant86 = MakeDbValueNull()
+
+				case 42:
+					value82 := unsafe.Slice((*float32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueVector(value82)
+
+				case 43:
+					value83 := unsafe.Slice((*float32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+					variant86 = MakeDbValueHalfvec(value83)
+
+				case 44:
+					value84 := unsafe.Slice((*int32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))))
+					value85 := unsafe.Slice((*float32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+					variant86 = MakeDbValueSparsevec(SparseVec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), value84, value85})
+
+				default:
+					panic("unreachable")
+				}
+
+				result87 = append(result87, variant86)
+			}
+
+			result88 = append(result88, DbRow{result87})
+		}
+
+		result95 = witTypes.Ok[DbResult, Error](DbResult{result43, result88})
+	case 1:
+		var variant94 Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value89 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant94 = MakeErrorConnectionFailure(value89)
+
+		case 1:
+			value90 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant94 = MakeErrorQueryParameterFailure(value90)
+
+		case 2:
+			value91 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant94 = MakeErrorQueryExecutionFailure(value91)
+
+		case 3:
+			value92 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant94 = MakeErrorQueryResponseFailure(value92)
+
+		case 4:
+			value93 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant94 = MakeErrorOther(value93)
+
+		default:
+			panic("unreachable")
+		}
+
+		result95 = witTypes.Err[DbResult, Error](variant94)
+	default:
+		panic("unreachable")
+	}
+	result96 := result95
+	return result96
+
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [method]db-transaction.query-stream
+func wasm_import_method_db_transaction_query_stream(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbTransaction) QueryStream(statement string, params []DbValue) witTypes.Result[*DbResultStream, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice33 := params
+	length35 := uint32(len(slice33))
+	result34 := witRuntime.Allocate(pinner, uintptr(length35*56), 8)
+	for index, element := range slice33 {
+		base := unsafe.Add(result34, index*56)
+
+		switch element.Tag() {
+		case DbValueCharacter:
+			payload := element.Character()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueInt2:
+			payload := element.Int2()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueInt4:
+			payload := element.Int4()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueInt8:
+			payload := element.Int8()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueFloat4:
+			payload := element.Float4()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueFloat8:
+			payload := element.Float8()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueNumeric:
+			payload := element.Numeric()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueBoolean:
+			payload := element.Boolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueText:
+			payload := element.Text()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueVarchar:
+			payload := element.Varchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			utf82 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf82)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf82)))
+
+		case DbValueBpchar:
+			payload := element.Bpchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			utf83 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf83)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf83)))
+
+		case DbValueTimestamp:
+			payload := element.Timestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTimestamptz:
+			payload := element.Timestamptz()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (((payload).Timestamp).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((((payload).Timestamp).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((((payload).Timestamp).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32((((payload).Timestamp).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32((((payload).Timestamp).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Offset
+
+		case DbValueDate:
+			payload := element.Date()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).Day))
+
+		case DbValueTime:
+			payload := element.Time()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Nanosecond)
+
+		case DbValueTimetz:
+			payload := element.Timetz()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32(((payload).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Offset
+
+		case DbValueInterval:
+			payload := element.Interval()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Months
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Days
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Microseconds
+
+		case DbValueBytea:
+			payload := element.Bytea()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		case DbValueJson:
+			payload := element.Json()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			utf84 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf84)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf84)))
+
+		case DbValueJsonb:
+			payload := element.Jsonb()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			utf85 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf85)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf85)))
+
+		case DbValueJsonpath:
+			payload := element.Jsonpath()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			utf86 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf86)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf86)))
+
+		case DbValueXml:
+			payload := element.Xml()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			utf87 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf87)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf87)))
+
+		case DbValueUuid:
+			payload := element.Uuid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).LowBits)
+
+		case DbValueInet:
+			payload := element.Inet()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+			switch payload.Tag() {
+			case golem_rdbms_types.IpAddressIpv4:
+				payload := payload.Ipv4()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).F0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32((payload).F1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).F2))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).F3))
+
+			case golem_rdbms_types.IpAddressIpv6:
+				payload := payload.Ipv6()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 10)) = int16(int32((payload).F0))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 12)) = int16(int32((payload).F1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 14)) = int16(int32((payload).F2))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 16)) = int16(int32((payload).F3))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 18)) = int16(int32((payload).F4))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 20)) = int16(int32((payload).F5))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 22)) = int16(int32((payload).F6))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 24)) = int16(int32((payload).F7))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueCidr:
+			payload := element.Cidr()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+			switch payload.Tag() {
+			case golem_rdbms_types.IpAddressIpv4:
+				payload := payload.Ipv4()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).F0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32((payload).F1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).F2))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).F3))
+
+			case golem_rdbms_types.IpAddressIpv6:
+				payload := payload.Ipv6()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 10)) = int16(int32((payload).F0))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 12)) = int16(int32((payload).F1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 14)) = int16(int32((payload).F2))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 16)) = int16(int32((payload).F3))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 18)) = int16(int32((payload).F4))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 20)) = int16(int32((payload).F5))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 22)) = int16(int32((payload).F6))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 24)) = int16(int32((payload).F7))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueMacaddr:
+			payload := element.Macaddr()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(((payload).Octets).F0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32(((payload).Octets).F1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32(((payload).Octets).F2))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32(((payload).Octets).F3))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Octets).F4))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Octets).F5))
+
+		case DbValueBit:
+			payload := element.Bit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			slice := payload
+			length := uint32(len(slice))
+			result9 := witRuntime.Allocate(pinner, uintptr(length*1), 1)
+			for index, element := range slice {
+				base := unsafe.Add(result9, index*1)
+				var result8 int32
+				if element {
+					result8 = 1
+				} else {
+					result8 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result8)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result9)))
+
+		case DbValueVarbit:
+			payload := element.Varbit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			slice11 := payload
+			length13 := uint32(len(slice11))
+			result12 := witRuntime.Allocate(pinner, uintptr(length13*1), 1)
+			for index, element := range slice11 {
+				base := unsafe.Add(result12, index*1)
+				var result10 int32
+				if element {
+					result10 = 1
+				} else {
+					result10 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result10)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length13)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result12)))
+
+		case DbValueInt4range:
+			payload := element.Int4range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+			switch (payload).Start.Tag() {
+			case Int4boundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			case Int4boundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			case Int4boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case Int4boundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			case Int4boundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			case Int4boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueInt8range:
+			payload := element.Int8range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+			switch (payload).Start.Tag() {
+			case Int8boundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			case Int8boundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			case Int8boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case Int8boundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+			case Int8boundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+			case Int8boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueNumrange:
+			payload := element.Numrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+
+			switch (payload).Start.Tag() {
+			case NumboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				utf814 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf814)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf814)))
+
+			case NumboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				utf815 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf815)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf815)))
+
+			case NumboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case NumboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+				utf816 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf816)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(utf816)))
+
+			case NumboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				utf817 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf817)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(utf817)))
+
+			case NumboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueTsrange:
+			payload := element.Tsrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+
+			switch (payload).Start.Tag() {
+			case TsboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case TsboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 36)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 37)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 42)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 36)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 37)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 42)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueTstzrange:
+			payload := element.Tstzrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+
+			switch (payload).Start.Tag() {
+			case TstzboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 28)) = (payload).Offset
+
+			case TstzboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 28)) = (payload).Offset
+
+			case TstzboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case TstzboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 44)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 45)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 46)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 52)) = (payload).Offset
+
+			case TstzboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 44)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 45)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 46)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 52)) = (payload).Offset
+
+			case TstzboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueDaterange:
+			payload := element.Daterange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+			switch (payload).Start.Tag() {
+			case DateboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((payload).Day))
+
+			case DateboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((payload).Day))
+
+			case DateboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case DateboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 29)) = int8(int32((payload).Day))
+
+			case DateboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 29)) = int8(int32((payload).Day))
+
+			case DateboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueMoney:
+			payload := element.Money()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueOid:
+			payload := element.Oid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueEnumeration:
+			payload := element.Enumeration()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36))
+			utf818 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf818)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf818)))
+			utf819 := unsafe.Pointer(unsafe.StringData((payload).Value))
+			pinner.Pin(utf819)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Value)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf819)))
+
+		case DbValueComposite:
+			payload := element.Composite()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(37))
+			utf820 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf820)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf820)))
+			slice21 := (payload).Values
+			length23 := uint32(len(slice21))
+			result22 := witRuntime.Allocate(pinner, uintptr(length23*4), 4)
+			for index, element := range slice21 {
+				base := unsafe.Add(result22, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).TakeHandle()
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length23)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result22)))
+
+		case DbValueDomain:
+			payload := element.Domain()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(38))
+			utf824 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf824)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf824)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = ((payload).Value).TakeHandle()
+
+		case DbValueArray:
+			payload := element.Array()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(39))
+			slice25 := payload
+			length27 := uint32(len(slice25))
+			result26 := witRuntime.Allocate(pinner, uintptr(length27*4), 4)
+			for index, element := range slice25 {
+				base := unsafe.Add(result26, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).TakeHandle()
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length27)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result26)))
+
+		case DbValueRange:
+			payload := element.Range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(40))
+			utf828 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf828)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf828)))
+
+			switch ((payload).Value).Start.Tag() {
+			case ValueBoundIncluded:
+				payload := ((payload).Value).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundExcluded:
+				payload := ((payload).Value).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch ((payload).Value).End.Tag() {
+			case ValueBoundIncluded:
+				payload := ((payload).Value).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundExcluded:
+				payload := ((payload).Value).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(41))
+
+		case DbValueVector:
+			payload := element.Vector()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(42))
+			data29 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data29)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data29)))
+
+		case DbValueHalfvec:
+			payload := element.Halfvec()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(43))
+			data30 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data30)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data30)))
+
+		case DbValueSparsevec:
+			payload := element.Sparsevec()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(44))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Dim
+			data31 := unsafe.Pointer(unsafe.SliceData((payload).Indices))
+			pinner.Pin(data31)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len((payload).Indices)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(data31)))
+			data32 := unsafe.Pointer(unsafe.SliceData((payload).Values))
+			pinner.Pin(data32)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len((payload).Values)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(data32)))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_transaction_query_stream((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result34), length35, returnArea)
+	var result40 witTypes.Result[*DbResultStream, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result40 = witTypes.Ok[*DbResultStream, Error](DbResultStreamFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value36)
+
+		case 2:
+			value37 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value37)
+
+		case 3:
+			value38 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value38)
+
+		case 4:
+			value39 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value39)
+
+		default:
+			panic("unreachable")
+		}
+
+		result40 = witTypes.Err[*DbResultStream, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result41 := result40
+	return result41
+
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [method]db-transaction.execute
+func wasm_import_method_db_transaction_execute(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *DbTransaction) Execute(statement string, params []DbValue) witTypes.Result[uint64, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (16 + 2*4), 8))
+	utf8 := unsafe.Pointer(unsafe.StringData(statement))
+	pinner.Pin(utf8)
+	slice33 := params
+	length35 := uint32(len(slice33))
+	result34 := witRuntime.Allocate(pinner, uintptr(length35*56), 8)
+	for index, element := range slice33 {
+		base := unsafe.Add(result34, index*56)
+
+		switch element.Tag() {
+		case DbValueCharacter:
+			payload := element.Character()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+		case DbValueInt2:
+			payload := element.Int2()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+			*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+		case DbValueInt4:
+			payload := element.Int4()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueInt8:
+			payload := element.Int8()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueFloat4:
+			payload := element.Float4()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+			*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueFloat8:
+			payload := element.Float8()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+			*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueNumeric:
+			payload := element.Numeric()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+			utf80 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf80)))
+
+		case DbValueBoolean:
+			payload := element.Boolean()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+			var result int32
+			if payload {
+				result = 1
+			} else {
+				result = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result)
+
+		case DbValueText:
+			payload := element.Text()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+			utf81 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf81)))
+
+		case DbValueVarchar:
+			payload := element.Varchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+			utf82 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf82)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf82)))
+
+		case DbValueBpchar:
+			payload := element.Bpchar()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+			utf83 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf83)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf83)))
+
+		case DbValueTimestamp:
+			payload := element.Timestamp()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = ((payload).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32(((payload).Time).Nanosecond)
+
+		case DbValueTimestamptz:
+			payload := element.Timestamptz()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (((payload).Timestamp).Date).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((((payload).Timestamp).Date).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((((payload).Timestamp).Date).Day))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 18)) = int8(int32((((payload).Timestamp).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = int32((((payload).Timestamp).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Offset
+
+		case DbValueDate:
+			payload := element.Date()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Year
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).Month))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).Day))
+
+		case DbValueTime:
+			payload := element.Time()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Nanosecond)
+
+		case DbValueTimetz:
+			payload := element.Timetz()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(((payload).Time).Hour))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32(((payload).Time).Minute))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32(((payload).Time).Second))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32(((payload).Time).Nanosecond)
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Offset
+
+		case DbValueInterval:
+			payload := element.Interval()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Months
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Days
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Microseconds
+
+		case DbValueBytea:
+			payload := element.Bytea()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			data := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+		case DbValueJson:
+			payload := element.Json()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			utf84 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf84)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf84)))
+
+		case DbValueJsonb:
+			payload := element.Jsonb()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			utf85 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf85)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf85)))
+
+		case DbValueJsonpath:
+			payload := element.Jsonpath()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			utf86 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf86)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf86)))
+
+		case DbValueXml:
+			payload := element.Xml()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			utf87 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf87)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf87)))
+
+		case DbValueUuid:
+			payload := element.Uuid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64((payload).HighBits)
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = int64((payload).LowBits)
+
+		case DbValueInet:
+			payload := element.Inet()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+			switch payload.Tag() {
+			case golem_rdbms_types.IpAddressIpv4:
+				payload := payload.Ipv4()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).F0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32((payload).F1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).F2))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).F3))
+
+			case golem_rdbms_types.IpAddressIpv6:
+				payload := payload.Ipv6()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 10)) = int16(int32((payload).F0))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 12)) = int16(int32((payload).F1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 14)) = int16(int32((payload).F2))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 16)) = int16(int32((payload).F3))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 18)) = int16(int32((payload).F4))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 20)) = int16(int32((payload).F5))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 22)) = int16(int32((payload).F6))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 24)) = int16(int32((payload).F7))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueCidr:
+			payload := element.Cidr()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+			switch payload.Tag() {
+			case golem_rdbms_types.IpAddressIpv4:
+				payload := payload.Ipv4()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32((payload).F0))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32((payload).F1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32((payload).F2))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32((payload).F3))
+
+			case golem_rdbms_types.IpAddressIpv6:
+				payload := payload.Ipv6()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 10)) = int16(int32((payload).F0))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 12)) = int16(int32((payload).F1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 14)) = int16(int32((payload).F2))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 16)) = int16(int32((payload).F3))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 18)) = int16(int32((payload).F4))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 20)) = int16(int32((payload).F5))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 22)) = int16(int32((payload).F6))
+				*(*int16)(unsafe.Add(unsafe.Pointer(base), 24)) = int16(int32((payload).F7))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueMacaddr:
+			payload := element.Macaddr()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(((payload).Octets).F0))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32(((payload).Octets).F1))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 10)) = int8(int32(((payload).Octets).F2))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 11)) = int8(int32(((payload).Octets).F3))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(((payload).Octets).F4))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 13)) = int8(int32(((payload).Octets).F5))
+
+		case DbValueBit:
+			payload := element.Bit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			slice := payload
+			length := uint32(len(slice))
+			result9 := witRuntime.Allocate(pinner, uintptr(length*1), 1)
+			for index, element := range slice {
+				base := unsafe.Add(result9, index*1)
+				var result8 int32
+				if element {
+					result8 = 1
+				} else {
+					result8 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result8)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result9)))
+
+		case DbValueVarbit:
+			payload := element.Varbit()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+			slice11 := payload
+			length13 := uint32(len(slice11))
+			result12 := witRuntime.Allocate(pinner, uintptr(length13*1), 1)
+			for index, element := range slice11 {
+				base := unsafe.Add(result12, index*1)
+				var result10 int32
+				if element {
+					result10 = 1
+				} else {
+					result10 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result10)
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length13)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result12)))
+
+		case DbValueInt4range:
+			payload := element.Int4range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+			switch (payload).Start.Tag() {
+			case Int4boundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			case Int4boundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			case Int4boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case Int4boundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			case Int4boundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			case Int4boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueInt8range:
+			payload := element.Int8range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+			switch (payload).Start.Tag() {
+			case Int8boundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			case Int8boundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+			case Int8boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case Int8boundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+			case Int8boundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+			case Int8boundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueNumrange:
+			payload := element.Numrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+
+			switch (payload).Start.Tag() {
+			case NumboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				utf814 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf814)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf814)))
+
+			case NumboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				utf815 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf815)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf815)))
+
+			case NumboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case NumboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+				utf816 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf816)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(utf816)))
+
+			case NumboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				utf817 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf817)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(utf817)))
+
+			case NumboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueTsrange:
+			payload := element.Tsrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+
+			switch (payload).Start.Tag() {
+			case TsboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case TsboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 36)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 37)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 42)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 32)) = ((payload).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 36)) = int8(int32(((payload).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 37)) = int8(int32(((payload).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(((payload).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32(((payload).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 42)) = int8(int32(((payload).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 44)) = int32(((payload).Time).Nanosecond)
+
+			case TsboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueTstzrange:
+			payload := element.Tstzrange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+
+			switch (payload).Start.Tag() {
+			case TstzboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 28)) = (payload).Offset
+
+			case TstzboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 21)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 22)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 28)) = (payload).Offset
+
+			case TstzboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case TstzboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 44)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 45)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 46)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 52)) = (payload).Offset
+
+			case TstzboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 36)) = (((payload).Timestamp).Date).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32((((payload).Timestamp).Date).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 41)) = int8(int32((((payload).Timestamp).Date).Day))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 44)) = int8(int32((((payload).Timestamp).Time).Hour))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 45)) = int8(int32((((payload).Timestamp).Time).Minute))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 46)) = int8(int32((((payload).Timestamp).Time).Second))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 48)) = int32((((payload).Timestamp).Time).Nanosecond)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 52)) = (payload).Offset
+
+			case TstzboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 32)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueDaterange:
+			payload := element.Daterange()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+			switch (payload).Start.Tag() {
+			case DateboundIncluded:
+				payload := (payload).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((payload).Day))
+
+			case DateboundExcluded:
+				payload := (payload).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 17)) = int8(int32((payload).Day))
+
+			case DateboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).End.Tag() {
+			case DateboundIncluded:
+				payload := (payload).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 29)) = int8(int32((payload).Day))
+
+			case DateboundExcluded:
+				payload := (payload).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 24)) = (payload).Year
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 28)) = int8(int32((payload).Month))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 29)) = int8(int32((payload).Day))
+
+			case DateboundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 20)) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueMoney:
+			payload := element.Money()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+			*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case DbValueOid:
+			payload := element.Oid()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+		case DbValueEnumeration:
+			payload := element.Enumeration()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36))
+			utf818 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf818)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf818)))
+			utf819 := unsafe.Pointer(unsafe.StringData((payload).Value))
+			pinner.Pin(utf819)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len((payload).Value)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf819)))
+
+		case DbValueComposite:
+			payload := element.Composite()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(37))
+			utf820 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf820)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf820)))
+			slice21 := (payload).Values
+			length23 := uint32(len(slice21))
+			result22 := witRuntime.Allocate(pinner, uintptr(length23*4), 4)
+			for index, element := range slice21 {
+				base := unsafe.Add(result22, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).TakeHandle()
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length23)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result22)))
+
+		case DbValueDomain:
+			payload := element.Domain()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(38))
+			utf824 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf824)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf824)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = ((payload).Value).TakeHandle()
+
+		case DbValueArray:
+			payload := element.Array()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(39))
+			slice25 := payload
+			length27 := uint32(len(slice25))
+			result26 := witRuntime.Allocate(pinner, uintptr(length27*4), 4)
+			for index, element := range slice25 {
+				base := unsafe.Add(result26, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).TakeHandle()
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length27)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result26)))
+
+		case DbValueRange:
+			payload := element.Range()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(40))
+			utf828 := unsafe.Pointer(unsafe.StringData((payload).Name))
+			pinner.Pin(utf828)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf828)))
+
+			switch ((payload).Value).Start.Tag() {
+			case ValueBoundIncluded:
+				payload := ((payload).Value).Start.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundExcluded:
+				payload := ((payload).Value).Start.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch ((payload).Value).End.Tag() {
+			case ValueBoundIncluded:
+				payload := ((payload).Value).End.Included()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundExcluded:
+				payload := ((payload).Value).End.Excluded()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 2*4))) = (payload).TakeHandle()
+
+			case ValueBoundUnbounded:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = int8(int32(2))
+
+			default:
+				panic("unreachable")
+			}
+
+		case DbValueNull:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(41))
+
+		case DbValueVector:
+			payload := element.Vector()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(42))
+			data29 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data29)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data29)))
+
+		case DbValueHalfvec:
+			payload := element.Halfvec()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(43))
+			data30 := unsafe.Pointer(unsafe.SliceData(payload))
+			pinner.Pin(data30)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data30)))
+
+		case DbValueSparsevec:
+			payload := element.Sparsevec()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(44))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Dim
+			data31 := unsafe.Pointer(unsafe.SliceData((payload).Indices))
+			pinner.Pin(data31)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len((payload).Indices)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(data31)))
+			data32 := unsafe.Pointer(unsafe.SliceData((payload).Values))
+			pinner.Pin(data32)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len((payload).Values)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(data32)))
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	wasm_import_method_db_transaction_execute((self).Handle(), uintptr(utf8), uint32(len(statement)), uintptr(result34), length35, returnArea)
+	var result40 witTypes.Result[uint64, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result40 = witTypes.Ok[uint64, Error](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryParameterFailure(value36)
+
+		case 2:
+			value37 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryExecutionFailure(value37)
+
+		case 3:
+			value38 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorQueryResponseFailure(value38)
+
+		case 4:
+			value39 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))
+
+			variant = MakeErrorOther(value39)
+
+		default:
+			panic("unreachable")
+		}
+
+		result40 = witTypes.Err[uint64, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result41 := result40
+	return result41
+
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [method]db-transaction.commit
+func wasm_import_method_db_transaction_commit(arg0 int32, arg1 uintptr)
+
+func (self *DbTransaction) Commit() witTypes.Result[witTypes.Unit, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	wasm_import_method_db_transaction_commit((self).Handle(), returnArea)
+	var result witTypes.Result[witTypes.Unit, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, Error](witTypes.Unit{})
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value0)
+
+		case 2:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value1)
+
+		case 3:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value2)
+
+		case 4:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value3)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Unit, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result4 := result
+	return result4
+
+}
+
+//go:wasmimport golem:rdbms/postgres@1.5.0 [method]db-transaction.rollback
+func wasm_import_method_db_transaction_rollback(arg0 int32, arg1 uintptr)
+
+func (self *DbTransaction) Rollback() witTypes.Result[witTypes.Unit, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	wasm_import_method_db_transaction_rollback((self).Handle(), returnArea)
+	var result witTypes.Result[witTypes.Unit, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, Error](witTypes.Unit{})
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryParameterFailure(value0)
+
+		case 2:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryExecutionFailure(value1)
+
+		case 3:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorQueryResponseFailure(value2)
+
+		case 4:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value3)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Unit, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result4 := result
+	return result4
+
+}
diff --git a/sdks/go/golem/internal/wit/golem_rdbms_types/empty.s b/sdks/go/golem/internal/wit/golem_rdbms_types/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_rdbms_types/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_rdbms_types/wit_bindings.go b/sdks/go/golem/internal/wit/golem_rdbms_types/wit_bindings.go
new file mode 100644
index 0000000000..6d5e9371cf
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_rdbms_types/wit_bindings.go
@@ -0,0 +1,107 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_rdbms_types
+
+import (
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+type Uuid struct {
+	HighBits uint64
+	LowBits  uint64
+}
+
+const (
+	IpAddressIpv4 uint8 = 0
+	IpAddressIpv6 uint8 = 1
+)
+
+type IpAddress struct {
+	tag   uint8
+	value any
+}
+
+func (self IpAddress) Tag() uint8 {
+	return self.tag
+}
+
+func (self IpAddress) Ipv4() witTypes.Tuple4[uint8, uint8, uint8, uint8] {
+	if self.tag != IpAddressIpv4 {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Tuple4[uint8, uint8, uint8, uint8])
+}
+func (self IpAddress) Ipv6() witTypes.Tuple8[uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint16] {
+	if self.tag != IpAddressIpv6 {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Tuple8[uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint16])
+}
+
+func MakeIpAddressIpv4(value witTypes.Tuple4[uint8, uint8, uint8, uint8]) IpAddress {
+	return IpAddress{IpAddressIpv4, value}
+}
+func MakeIpAddressIpv6(value witTypes.Tuple8[uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint16]) IpAddress {
+	return IpAddress{IpAddressIpv6, value}
+}
+
+type MacAddress struct {
+	Octets witTypes.Tuple6[uint8, uint8, uint8, uint8, uint8, uint8]
+}
+
+type Date struct {
+	Year  int32
+	Month uint8
+	Day   uint8
+}
+
+type Time struct {
+	Hour       uint8
+	Minute     uint8
+	Second     uint8
+	Nanosecond uint32
+}
+
+type Timestamp struct {
+	Date Date
+	Time Time
+}
+
+type Timestamptz struct {
+	Timestamp Timestamp
+	Offset    int32
+}
+
+type Timetz struct {
+	Time   Time
+	Offset int32
+}
diff --git a/sdks/go/golem/internal/wit/golem_secrets_reveal/empty.s b/sdks/go/golem/internal/wit/golem_secrets_reveal/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_secrets_reveal/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_secrets_reveal/wit_bindings.go b/sdks/go/golem/internal/wit/golem_secrets_reveal/wit_bindings.go
new file mode 100644
index 0000000000..386bec30bf
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_secrets_reveal/wit_bindings.go
@@ -0,0 +1,2389 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_secrets_reveal
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_secrets_types"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type SecretError = golem_secrets_types.SecretError
+type Secret = golem_core_types.Secret
+type SchemaGraph = golem_core_types.SchemaGraph
+type SchemaValueTree = golem_core_types.SchemaValueTree
+
+//go:wasmimport golem:secrets/reveal@0.1.0 reveal
+func wasm_import_reveal(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 int32, arg6 uintptr)
+
+func Reveal(s *golem_core_types.Secret, expected golem_core_types.SchemaGraph) witTypes.Result[golem_core_types.SchemaValueTree, golem_secrets_types.SecretError] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	slice114 := (expected).TypeNodes
+	length116 := uint32(len(slice114))
+	result115 := witRuntime.Allocate(pinner, uintptr(length116*(56+22*4)), 8)
+	for index, element := range slice114 {
+		base := unsafe.Add(result115, index*(56+22*4))
+
+		switch (element).Body.Tag() {
+		case golem_core_types.SchemaTypeBodyRefType:
+			payload := (element).Body.RefType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaTypeBodyBoolType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+		case golem_core_types.SchemaTypeBodyS8Type:
+			payload := (element).Body.S8Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf8 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyS16Type:
+			payload := (element).Body.S16Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf80 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf80)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf80)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyS32Type:
+			payload := (element).Body.S32Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf81 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf81)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf81)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyS64Type:
+			payload := (element).Body.S64Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf82 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf82)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf82)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU8Type:
+			payload := (element).Body.U8Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf83 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf83)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf83)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU16Type:
+			payload := (element).Body.U16Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf84 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf84)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf84)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU32Type:
+			payload := (element).Body.U32Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf85 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf85)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf85)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU64Type:
+			payload := (element).Body.U64Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf86 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf86)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf86)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyF32Type:
+			payload := (element).Body.F32Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf87 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf87)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf87)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyF64Type:
+			payload := (element).Body.F64Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf88 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf88)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf88)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyCharType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+
+		case golem_core_types.SchemaTypeBodyStringType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+
+		case golem_core_types.SchemaTypeBodyRecordType:
+			payload := (element).Body.RecordType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			slice18 := payload
+			length20 := uint32(len(slice18))
+			result19 := witRuntime.Allocate(pinner, uintptr(length20*(17*4)), 4)
+			for index, element := range slice18 {
+				base := unsafe.Add(result19, index*(17*4))
+				utf89 := unsafe.Pointer(unsafe.StringData((element).Name))
+				pinner.Pin(utf89)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf89)))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+					utf810 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf810)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf810)))
+
+				default:
+					panic("unreachable")
+				}
+				slice := ((element).Metadata).Aliases
+				length := uint32(len(slice))
+				result := witRuntime.Allocate(pinner, uintptr(length*(2*4)), 4)
+				for index, element := range slice {
+					base := unsafe.Add(result, index*(2*4))
+					utf811 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf811)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf811)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result)))
+				slice13 := ((element).Metadata).Examples
+				length15 := uint32(len(slice13))
+				result14 := witRuntime.Allocate(pinner, uintptr(length15*(2*4)), 4)
+				for index, element := range slice13 {
+					base := unsafe.Add(result14, index*(2*4))
+					utf812 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf812)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf812)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = uint32(length15)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result14)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(1))
+					utf816 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf816)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf816)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(3))
+						utf817 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf817)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uintptr(uintptr(utf817)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length20)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result19)))
+
+		case golem_core_types.SchemaTypeBodyVariantType:
+			payload := (element).Body.VariantType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			slice33 := payload
+			length35 := uint32(len(slice33))
+			result34 := witRuntime.Allocate(pinner, uintptr(length35*(8+16*4)), 4)
+			for index, element := range slice33 {
+				base := unsafe.Add(result34, index*(8+16*4))
+				utf821 := unsafe.Pointer(unsafe.StringData((element).Name))
+				pinner.Pin(utf821)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf821)))
+
+				switch (element).Payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (element).Payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+					utf822 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf822)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf822)))
+
+				default:
+					panic("unreachable")
+				}
+				slice24 := ((element).Metadata).Aliases
+				length26 := uint32(len(slice24))
+				result25 := witRuntime.Allocate(pinner, uintptr(length26*(2*4)), 4)
+				for index, element := range slice24 {
+					base := unsafe.Add(result25, index*(2*4))
+					utf823 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf823)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf823)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length26)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result25)))
+				slice28 := ((element).Metadata).Examples
+				length30 := uint32(len(slice28))
+				result29 := witRuntime.Allocate(pinner, uintptr(length30*(2*4)), 4)
+				for index, element := range slice28 {
+					base := unsafe.Add(result29, index*(2*4))
+					utf827 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf827)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf827)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length30)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result29)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+					utf831 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf831)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf831)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+						utf832 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf832)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf832)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length35)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result34)))
+
+		case golem_core_types.SchemaTypeBodyEnumType:
+			payload := (element).Body.EnumType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			slice37 := payload
+			length39 := uint32(len(slice37))
+			result38 := witRuntime.Allocate(pinner, uintptr(length39*(2*4)), 4)
+			for index, element := range slice37 {
+				base := unsafe.Add(result38, index*(2*4))
+				utf836 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf836)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf836)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length39)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result38)))
+
+		case golem_core_types.SchemaTypeBodyFlagsType:
+			payload := (element).Body.FlagsType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			slice41 := payload
+			length43 := uint32(len(slice41))
+			result42 := witRuntime.Allocate(pinner, uintptr(length43*(2*4)), 4)
+			for index, element := range slice41 {
+				base := unsafe.Add(result42, index*(2*4))
+				utf840 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf840)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf840)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length43)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result42)))
+
+		case golem_core_types.SchemaTypeBodyTupleType:
+			payload := (element).Body.TupleType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			slice44 := payload
+			length46 := uint32(len(slice44))
+			result45 := witRuntime.Allocate(pinner, uintptr(length46*4), 4)
+			for index, element := range slice44 {
+				base := unsafe.Add(result45, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length46)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result45)))
+
+		case golem_core_types.SchemaTypeBodyListType:
+			payload := (element).Body.ListType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaTypeBodyFixedListType:
+			payload := (element).Body.FixedListType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Element
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Length)
+
+		case golem_core_types.SchemaTypeBodyMapType:
+			payload := (element).Body.MapType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Key
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Value
+
+		case golem_core_types.SchemaTypeBodyOptionType:
+			payload := (element).Body.OptionType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaTypeBodyResultType:
+			payload := (element).Body.ResultType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+			switch (payload).Ok.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Ok.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).Err.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Err.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyTextType:
+			payload := (element).Body.TextType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+			switch (payload).Languages.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Languages.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				slice48 := payload
+				length50 := uint32(len(slice48))
+				result49 := witRuntime.Allocate(pinner, uintptr(length50*(2*4)), 4)
+				for index, element := range slice48 {
+					base := unsafe.Add(result49, index*(2*4))
+					utf847 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf847)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf847)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length50)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result49)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MinLength.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MinLength.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MaxLength.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MaxLength.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).Regex.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Regex.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(1))
+				utf851 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf851)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = uint32(uintptr(uintptr(utf851)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyBinaryType:
+			payload := (element).Body.BinaryType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+
+			switch (payload).MimeTypes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MimeTypes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				slice53 := payload
+				length55 := uint32(len(slice53))
+				result54 := witRuntime.Allocate(pinner, uintptr(length55*(2*4)), 4)
+				for index, element := range slice53 {
+					base := unsafe.Add(result54, index*(2*4))
+					utf852 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf852)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf852)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length55)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result54)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MinBytes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MinBytes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MaxBytes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MaxBytes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyPathType:
+			payload := (element).Body.PathType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Direction))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Kind))
+
+			switch (payload).AllowedMimeTypes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedMimeTypes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+				slice57 := payload
+				length59 := uint32(len(slice57))
+				result58 := witRuntime.Allocate(pinner, uintptr(length59*(2*4)), 4)
+				for index, element := range slice57 {
+					base := unsafe.Add(result58, index*(2*4))
+					utf856 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf856)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf856)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length59)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result58)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).AllowedExtensions.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedExtensions.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+				slice61 := payload
+				length63 := uint32(len(slice61))
+				result62 := witRuntime.Allocate(pinner, uintptr(length63*(2*4)), 4)
+				for index, element := range slice61 {
+					base := unsafe.Add(result62, index*(2*4))
+					utf860 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf860)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf860)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length63)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result62)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyUrlType:
+			payload := (element).Body.UrlType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+
+			switch (payload).AllowedSchemes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedSchemes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				slice65 := payload
+				length67 := uint32(len(slice65))
+				result66 := witRuntime.Allocate(pinner, uintptr(length67*(2*4)), 4)
+				for index, element := range slice65 {
+					base := unsafe.Add(result66, index*(2*4))
+					utf864 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf864)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf864)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length67)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result66)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).AllowedHosts.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedHosts.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				slice69 := payload
+				length71 := uint32(len(slice69))
+				result70 := witRuntime.Allocate(pinner, uintptr(length71*(2*4)), 4)
+				for index, element := range slice69 {
+					base := unsafe.Add(result70, index*(2*4))
+					utf868 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf868)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf868)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(length71)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(result70)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyDatetimeType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+		case golem_core_types.SchemaTypeBodyDurationType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+		case golem_core_types.SchemaTypeBodyQuantityType:
+			payload := (element).Body.QuantityType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			utf872 := unsafe.Pointer(unsafe.StringData((payload).BaseUnit))
+			pinner.Pin(utf872)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).BaseUnit)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf872)))
+			slice74 := (payload).AllowedSuffixes
+			length76 := uint32(len(slice74))
+			result75 := witRuntime.Allocate(pinner, uintptr(length76*(2*4)), 4)
+			for index, element := range slice74 {
+				base := unsafe.Add(result75, index*(2*4))
+				utf873 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf873)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf873)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length76)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result75)))
+
+			switch (payload).Min.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Min.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))) = (payload).Mantissa
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = (payload).Scale
+				utf877 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+				pinner.Pin(utf877)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))) = uint32(uint32(len((payload).Unit)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uintptr(uintptr(utf877)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).Max.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Max.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))) = (payload).Mantissa
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))) = (payload).Scale
+				utf878 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+				pinner.Pin(utf878)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))) = uint32(uint32(len((payload).Unit)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4))) = uint32(uintptr(uintptr(utf878)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyUnionType:
+			payload := (element).Body.UnionType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			slice98 := (payload).Branches
+			length100 := uint32(len(slice98))
+			result99 := witRuntime.Allocate(pinner, uintptr(length100*(23*4)), 4)
+			for index, element := range slice98 {
+				base := unsafe.Add(result99, index*(23*4))
+				utf879 := unsafe.Pointer(unsafe.StringData((element).Tag))
+				pinner.Pin(utf879)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Tag)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf879)))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+				switch (element).Discriminator.Tag() {
+				case golem_core_types.DiscriminatorRulePrefix:
+					payload := (element).Discriminator.Prefix()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+					utf880 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf880)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf880)))
+
+				case golem_core_types.DiscriminatorRuleSuffix:
+					payload := (element).Discriminator.Suffix()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+					utf881 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf881)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf881)))
+
+				case golem_core_types.DiscriminatorRuleContains:
+					payload := (element).Discriminator.Contains()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(2))
+					utf882 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf882)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf882)))
+
+				case golem_core_types.DiscriminatorRuleRegex:
+					payload := (element).Discriminator.Regex()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(3))
+					utf883 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf883)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf883)))
+
+				case golem_core_types.DiscriminatorRuleFieldEquals:
+					payload := (element).Discriminator.FieldEquals()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(4))
+					utf884 := unsafe.Pointer(unsafe.StringData((payload).FieldName))
+					pinner.Pin(utf884)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((payload).FieldName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf884)))
+
+					switch (payload).Literal.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Literal.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+						utf885 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf885)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf885)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.DiscriminatorRuleFieldAbsent:
+					payload := (element).Discriminator.FieldAbsent()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(5))
+					utf886 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf886)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf886)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+					utf887 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf887)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(utf887)))
+
+				default:
+					panic("unreachable")
+				}
+				slice89 := ((element).Metadata).Aliases
+				length91 := uint32(len(slice89))
+				result90 := witRuntime.Allocate(pinner, uintptr(length91*(2*4)), 4)
+				for index, element := range slice89 {
+					base := unsafe.Add(result90, index*(2*4))
+					utf888 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf888)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf888)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(length91)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(result90)))
+				slice93 := ((element).Metadata).Examples
+				length95 := uint32(len(slice93))
+				result94 := witRuntime.Allocate(pinner, uintptr(length95*(2*4)), 4)
+				for index, element := range slice93 {
+					base := unsafe.Add(result94, index*(2*4))
+					utf892 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf892)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf892)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(length95)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(result94)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(1))
+					utf896 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf896)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf896)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(3))
+						utf897 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf897)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(utf897)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length100)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result99)))
+
+		case golem_core_types.SchemaTypeBodySecretType:
+			payload := (element).Body.SecretType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Inner
+
+			switch (payload).Category.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Category.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+				utf8101 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8101)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8101)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyQuotaTokenType:
+			payload := (element).Body.QuotaTokenType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+			switch (payload).ResourceName.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).ResourceName.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				utf8102 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8102)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf8102)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyFutureType:
+			payload := (element).Body.FutureType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyStreamType:
+			payload := (element).Body.StreamType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		default:
+			panic("unreachable")
+		}
+
+		switch ((element).Metadata).Doc.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Metadata).Doc.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(1))
+			utf8103 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8103)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4))) = uint32(uintptr(uintptr(utf8103)))
+
+		default:
+			panic("unreachable")
+		}
+		slice105 := ((element).Metadata).Aliases
+		length107 := uint32(len(slice105))
+		result106 := witRuntime.Allocate(pinner, uintptr(length107*(2*4)), 4)
+		for index, element := range slice105 {
+			base := unsafe.Add(result106, index*(2*4))
+			utf8104 := unsafe.Pointer(unsafe.StringData(element))
+			pinner.Pin(utf8104)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8104)))
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length107)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result106)))
+		slice109 := ((element).Metadata).Examples
+		length111 := uint32(len(slice109))
+		result110 := witRuntime.Allocate(pinner, uintptr(length111*(2*4)), 4)
+		for index, element := range slice109 {
+			base := unsafe.Add(result110, index*(2*4))
+			utf8108 := unsafe.Pointer(unsafe.StringData(element))
+			pinner.Pin(utf8108)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8108)))
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length111)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result110)))
+
+		switch ((element).Metadata).Deprecated.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Metadata).Deprecated.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(1))
+			utf8112 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8112)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4))) = uint32(uintptr(uintptr(utf8112)))
+
+		default:
+			panic("unreachable")
+		}
+
+		switch ((element).Metadata).Role.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Metadata).Role.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(1))
+
+			switch payload.Tag() {
+			case golem_core_types.RoleMultimodal:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(0))
+
+			case golem_core_types.RoleUnstructuredText:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(1))
+
+			case golem_core_types.RoleUnstructuredBinary:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(2))
+
+			case golem_core_types.RoleOther:
+				payload := payload.Other()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(3))
+				utf8113 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8113)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4))) = uint32(uintptr(uintptr(utf8113)))
+
+			default:
+				panic("unreachable")
+			}
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	slice119 := (expected).Defs
+	length121 := uint32(len(slice119))
+	result120 := witRuntime.Allocate(pinner, uintptr(length121*(6*4)), 4)
+	for index, element := range slice119 {
+		base := unsafe.Add(result120, index*(6*4))
+		utf8117 := unsafe.Pointer(unsafe.StringData((element).Id))
+		pinner.Pin(utf8117)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8117)))
+
+		switch (element).Name.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := (element).Name.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+			utf8118 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8118)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8118)))
+
+		default:
+			panic("unreachable")
+		}
+		*(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body
+
+	}
+
+	wasm_import_reveal((s).Handle(), uintptr(result115), length116, uintptr(result120), length121, (expected).Root, returnArea)
+	var result147 witTypes.Result[golem_core_types.SchemaValueTree, golem_secrets_types.SecretError]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		result142 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(16+4*4))
+			var variant141 golem_core_types.SchemaValueNode
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+			case 1:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 2:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 3:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 4:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 5:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 6:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 7:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 8:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 9:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 10:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 11:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 12:
+				value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant141 = golem_core_types.MakeSchemaValueNodeStringValue(value)
+
+			case 13:
+				result122 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result122 = append(result122, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant141 = golem_core_types.MakeSchemaValueNodeRecordValue(result122)
+
+			case 14:
+				var option witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+				case 0:
+
+					option = witTypes.None[int32]()
+				case 1:
+
+					option = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+				default:
+					panic("unreachable")
+				}
+
+				variant141 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option})
+
+			case 15:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 16:
+				result123 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+					result123 = append(result123, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+				}
+
+				variant141 = golem_core_types.MakeSchemaValueNodeFlagsValue(result123)
+
+			case 17:
+				result124 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result124 = append(result124, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant141 = golem_core_types.MakeSchemaValueNodeTupleValue(result124)
+
+			case 18:
+				result125 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result125 = append(result125, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant141 = golem_core_types.MakeSchemaValueNodeListValue(result125)
+
+			case 19:
+				result126 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result126 = append(result126, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant141 = golem_core_types.MakeSchemaValueNodeFixedListValue(result126)
+
+			case 20:
+				result127 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+					result127 = append(result127, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+				}
+
+				variant141 = golem_core_types.MakeSchemaValueNodeMapValue(result127)
+
+			case 21:
+				var option128 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option128 = witTypes.None[int32]()
+				case 1:
+
+					option128 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+				default:
+					panic("unreachable")
+				}
+
+				variant141 = golem_core_types.MakeSchemaValueNodeOptionValue(option128)
+
+			case 22:
+				var variant golem_core_types.ResultValuePayload
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+					var option129 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+					case 0:
+
+						option129 = witTypes.None[int32]()
+					case 1:
+
+						option129 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+					default:
+						panic("unreachable")
+					}
+
+					variant = golem_core_types.MakeResultValuePayloadOkValue(option129)
+
+				case 1:
+					var option130 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+					case 0:
+
+						option130 = witTypes.None[int32]()
+					case 1:
+
+						option130 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+					default:
+						panic("unreachable")
+					}
+
+					variant = golem_core_types.MakeResultValuePayloadErrValue(option130)
+
+				default:
+					panic("unreachable")
+				}
+
+				variant141 = golem_core_types.MakeSchemaValueNodeResultValue(variant)
+
+			case 23:
+				value131 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var option133 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+
+					option133 = witTypes.None[string]()
+				case 1:
+					value132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+					option133 = witTypes.Some[string](value132)
+				default:
+					panic("unreachable")
+				}
+
+				variant141 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value131, option133})
+
+			case 24:
+				value134 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var option136 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+
+					option136 = witTypes.None[string]()
+				case 1:
+					value135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+					option136 = witTypes.Some[string](value135)
+				default:
+					panic("unreachable")
+				}
+
+				variant141 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value134, option136})
+
+			case 25:
+				value137 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant141 = golem_core_types.MakeSchemaValueNodePathValue(value137)
+
+			case 26:
+				value138 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant141 = golem_core_types.MakeSchemaValueNodeUrlValue(value138)
+
+			case 27:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+			case 28:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+			case 29:
+				value139 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				variant141 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value139})
+
+			case 30:
+				value140 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant141 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value140, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+			case 31:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+			case 32:
+
+				variant141 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+			default:
+				panic("unreachable")
+			}
+
+			result142 = append(result142, variant141)
+		}
+
+		result147 = witTypes.Ok[golem_core_types.SchemaValueTree, golem_secrets_types.SecretError](golem_core_types.SchemaValueTree{result142, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))})
+	case 1:
+		var variant146 golem_secrets_types.SecretError
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value143 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant146 = golem_secrets_types.MakeSecretErrorUnavailable(value143)
+
+		case 1:
+			value144 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant146 = golem_secrets_types.MakeSecretErrorVersionNotFound(golem_secrets_types.SecretVersion{value144})
+
+		case 2:
+			value145 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant146 = golem_secrets_types.MakeSecretErrorInternal(value145)
+
+		default:
+			panic("unreachable")
+		}
+
+		result147 = witTypes.Err[golem_core_types.SchemaValueTree, golem_secrets_types.SecretError](variant146)
+	default:
+		panic("unreachable")
+	}
+	result148 := result147
+	return result148
+
+}
diff --git a/sdks/go/golem/internal/wit/golem_secrets_types/empty.s b/sdks/go/golem/internal/wit/golem_secrets_types/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_secrets_types/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_secrets_types/wit_bindings.go b/sdks/go/golem/internal/wit/golem_secrets_types/wit_bindings.go
new file mode 100644
index 0000000000..e5baf56993
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_secrets_types/wit_bindings.go
@@ -0,0 +1,206 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_secrets_types
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_system_clock"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type Datetime = wasi_clocks_0_3_0_system_clock.Instant
+type Secret = golem_core_types.Secret
+
+// The opaque handle to a sensitive value is defined in
+// `golem:core/types` so it can travel inside a `schema-value-tree` as an
+// unforgeable owned handle. This interface exposes only safe metadata
+// operations over that handle.
+//
+// Resource handles are scoped to a component instance's
+// resource table. When a secret is passed across a component
+// boundary (e.g., agent → tool via `tool-rpc.invoke`'s
+// `value-tree`), the runtime issues a fresh handle in the
+// receiving instance's table that points at the same
+// host-side state. The wire form carries only the
+// `secret-id`, never plaintext.
+// Stable, opaque identifier scoped to the deployment.
+type SecretId struct {
+	Bytes []uint8
+}
+
+// A secret-store-assigned, monotonic version identifier. The
+// secret-store backend defines the ordering and the format;
+// the type-tree treats it as opaque.
+type SecretVersion struct {
+	Bytes []uint8
+}
+
+type SecretMetadata struct {
+	// Config-key path the secret resolved from, when applicable.
+	// `none` for secrets returned in tool-result position.
+	ConfigKey witTypes.Option[[]string]
+	// Pinned version captured at resolve-time. `none` for
+	// dynamic-origin secrets (e.g. returned from a tool that
+	// didn't itself have a versioned source).
+	Version witTypes.Option[SecretVersion]
+	// Time of resolution.
+	ResolvedAt wasi_clocks_0_3_0_system_clock.Instant
+	// The semantic category declared on the secret's schema type, when
+	// known. Mirrors `secret-spec.category` in `golem:core/types`.
+	Category witTypes.Option[string]
+}
+
+const (
+	// The secret was bound but its current resolution failed
+	// (e.g., the secret-store entry was deleted between binding
+	// and reveal, or the network to the store is partitioned).
+	SecretErrorUnavailable uint8 = 0
+	// The secret was version-pinned and the pinned version no
+	// longer exists (administratively destroyed).
+	SecretErrorVersionNotFound uint8 = 1
+	// Internal runtime error (carries an opaque message; never
+	// includes plaintext).
+	SecretErrorInternal uint8 = 2
+)
+
+// Errors common to operations on secrets.
+type SecretError struct {
+	tag   uint8
+	value any
+}
+
+func (self SecretError) Tag() uint8 {
+	return self.tag
+}
+
+func (self SecretError) Unavailable() string {
+	if self.tag != SecretErrorUnavailable {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self SecretError) VersionNotFound() SecretVersion {
+	if self.tag != SecretErrorVersionNotFound {
+		panic("tag mismatch")
+	}
+	return self.value.(SecretVersion)
+}
+func (self SecretError) Internal() string {
+	if self.tag != SecretErrorInternal {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+
+func MakeSecretErrorUnavailable(value string) SecretError {
+	return SecretError{SecretErrorUnavailable, value}
+}
+func MakeSecretErrorVersionNotFound(value SecretVersion) SecretError {
+	return SecretError{SecretErrorVersionNotFound, value}
+}
+func MakeSecretErrorInternal(value string) SecretError {
+	return SecretError{SecretErrorInternal, value}
+}
+
+//go:wasmimport golem:secrets/types@0.1.0 id
+func wasm_import_id(arg0 int32, arg1 uintptr)
+
+func Id(s *golem_core_types.Secret) SecretId {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	wasm_import_id((s).Handle(), returnArea)
+	value := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	result := SecretId{value}
+	return result
+
+}
+
+//go:wasmimport golem:secrets/types@0.1.0 metadata
+func wasm_import_metadata(arg0 int32, arg1 uintptr)
+
+func Metadata(s *golem_core_types.Secret) SecretMetadata {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (24 + 8*4), 8))
+	wasm_import_metadata((s).Handle(), returnArea)
+	var option witTypes.Option[[]string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[[]string]()
+	case 1:
+		result := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(2*4))
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+			result = append(result, value)
+		}
+
+		option = witTypes.Some[[]string](result)
+	default:
+		panic("unreachable")
+	}
+	var option1 witTypes.Option[SecretVersion]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))) {
+	case 0:
+
+		option1 = witTypes.None[SecretVersion]()
+	case 1:
+		value0 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4))))
+
+		option1 = witTypes.Some[SecretVersion](SecretVersion{value0})
+	default:
+		panic("unreachable")
+	}
+	var option3 witTypes.Option[string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 6*4)))) {
+	case 0:
+
+		option3 = witTypes.None[string]()
+	case 1:
+		value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 8*4))))
+
+		option3 = witTypes.Some[string](value2)
+	default:
+		panic("unreachable")
+	}
+	result4 := SecretMetadata{option, option1, wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (6 * 4))), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 6*4))))}, option3}
+	return result4
+
+}
diff --git a/sdks/go/golem/internal/wit/golem_websocket_client/empty.s b/sdks/go/golem/internal/wit/golem_websocket_client/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_websocket_client/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/golem_websocket_client/wit_bindings.go b/sdks/go/golem/internal/wit/golem_websocket_client/wit_bindings.go
new file mode 100644
index 0000000000..53fbaa5e5f
--- /dev/null
+++ b/sdks/go/golem/internal/wit/golem_websocket_client/wit_bindings.go
@@ -0,0 +1,691 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package golem_websocket_client
+
+import (
+	witAsync "go.bytecodealliance.org/pkg/wit/async"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type CloseInfo struct {
+	Code   uint16
+	Reason string
+}
+
+const (
+	ErrorConnectionFailure uint8 = 0
+	ErrorSendFailure       uint8 = 1
+	ErrorReceiveFailure    uint8 = 2
+	ErrorProtocolError     uint8 = 3
+	ErrorClosed            uint8 = 4
+	ErrorOther             uint8 = 5
+)
+
+type Error struct {
+	tag   uint8
+	value any
+}
+
+func (self Error) Tag() uint8 {
+	return self.tag
+}
+
+func (self Error) ConnectionFailure() string {
+	if self.tag != ErrorConnectionFailure {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) SendFailure() string {
+	if self.tag != ErrorSendFailure {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) ReceiveFailure() string {
+	if self.tag != ErrorReceiveFailure {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) ProtocolError() string {
+	if self.tag != ErrorProtocolError {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) Closed() witTypes.Option[CloseInfo] {
+	if self.tag != ErrorClosed {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[CloseInfo])
+}
+func (self Error) Other() string {
+	if self.tag != ErrorOther {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+
+func MakeErrorConnectionFailure(value string) Error {
+	return Error{ErrorConnectionFailure, value}
+}
+func MakeErrorSendFailure(value string) Error {
+	return Error{ErrorSendFailure, value}
+}
+func MakeErrorReceiveFailure(value string) Error {
+	return Error{ErrorReceiveFailure, value}
+}
+func MakeErrorProtocolError(value string) Error {
+	return Error{ErrorProtocolError, value}
+}
+func MakeErrorClosed(value witTypes.Option[CloseInfo]) Error {
+	return Error{ErrorClosed, value}
+}
+func MakeErrorOther(value string) Error {
+	return Error{ErrorOther, value}
+}
+
+const (
+	MessageText   uint8 = 0
+	MessageBinary uint8 = 1
+)
+
+// A WebSocket message — text or binary
+type Message struct {
+	tag   uint8
+	value any
+}
+
+func (self Message) Tag() uint8 {
+	return self.tag
+}
+
+func (self Message) Text() string {
+	if self.tag != MessageText {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Message) Binary() []uint8 {
+	if self.tag != MessageBinary {
+		panic("tag mismatch")
+	}
+	return self.value.([]uint8)
+}
+
+func MakeMessageText(value string) Message {
+	return Message{MessageText, value}
+}
+func MakeMessageBinary(value []uint8) Message {
+	return Message{MessageBinary, value}
+}
+
+//go:wasmimport golem:websocket/client@1.5.0 [resource-drop]websocket-connection
+func resourceDropWebsocketConnection(handle int32)
+
+// A WebSocket connection resource
+type WebsocketConnection struct {
+	handle *witRuntime.Handle
+}
+
+func (self *WebsocketConnection) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *WebsocketConnection) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *WebsocketConnection) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *WebsocketConnection) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropWebsocketConnection(handle)
+	}
+}
+
+func WebsocketConnectionFromOwnHandle(handleValue int32) *WebsocketConnection {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &WebsocketConnection{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropWebsocketConnection(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func WebsocketConnectionFromBorrowHandle(handleValue int32) *WebsocketConnection {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &WebsocketConnection{handle}
+}
+
+//go:wasmimport golem:websocket/client@1.5.0 [static]websocket-connection.connect
+func wasm_import_static_websocket_connection_connect(arg0 uintptr, arg1 uint32, arg2 int32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func WebsocketConnectionConnect(url string, headers witTypes.Option[[]witTypes.Tuple2[string, string]]) witTypes.Result[*WebsocketConnection, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (6 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(url))
+	pinner.Pin(utf8)
+	var option int32
+	var option2 uintptr
+	var option3 uint32
+	switch headers.Tag() {
+	case witTypes.OptionNone:
+
+		option = int32(0)
+		option2 = 0
+		option3 = 0
+	case witTypes.OptionSome:
+		payload := headers.Some()
+		slice := payload
+		length := uint32(len(slice))
+		result := witRuntime.Allocate(pinner, uintptr(length*(4*4)), 4)
+		for index, element := range slice {
+			base := unsafe.Add(result, index*(4*4))
+			utf80 := unsafe.Pointer(unsafe.StringData((element).F0))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).F0)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf80)))
+			utf81 := unsafe.Pointer(unsafe.StringData((element).F1))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).F1)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf81)))
+
+		}
+
+		option = int32(1)
+		option2 = uintptr(result)
+		option3 = length
+	default:
+		panic("unreachable")
+	}
+	wasm_import_static_websocket_connection_connect(uintptr(utf8), uint32(len(url)), option, option2, option3, returnArea)
+	var result10 witTypes.Result[*WebsocketConnection, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result10 = witTypes.Ok[*WebsocketConnection, Error](WebsocketConnectionFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorSendFailure(value4)
+
+		case 2:
+			value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorReceiveFailure(value5)
+
+		case 3:
+			value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorProtocolError(value6)
+
+		case 4:
+			var option8 witTypes.Option[CloseInfo]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+
+				option8 = witTypes.None[CloseInfo]()
+			case 1:
+				value7 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4))))
+
+				option8 = witTypes.Some[CloseInfo](CloseInfo{uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))), value7})
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorClosed(option8)
+
+		case 5:
+			value9 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value9)
+
+		default:
+			panic("unreachable")
+		}
+
+		result10 = witTypes.Err[*WebsocketConnection, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result11 := result10
+	return result11
+
+}
+
+//go:wasmimport golem:websocket/client@1.5.0 [method]websocket-connection.send
+func wasm_import_method_websocket_connection_send(arg0 int32, arg1 int32, arg2 uintptr, arg3 uint32, arg4 uintptr)
+
+func (self *WebsocketConnection) Send(message Message) witTypes.Result[witTypes.Unit, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (6 * 4), 4))
+	var variant int32
+	var variant0 uintptr
+	var variant1 uint32
+	switch message.Tag() {
+	case MessageText:
+		payload := message.Text()
+		utf8 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf8)
+
+		variant = int32(0)
+		variant0 = uintptr(utf8)
+		variant1 = uint32(len(payload))
+
+	case MessageBinary:
+		payload := message.Binary()
+		data := unsafe.Pointer(unsafe.SliceData(payload))
+		pinner.Pin(data)
+
+		variant = int32(1)
+		variant0 = uintptr(data)
+		variant1 = uint32(len(payload))
+
+	default:
+		panic("unreachable")
+	}
+	wasm_import_method_websocket_connection_send((self).Handle(), variant, variant0, variant1, returnArea)
+	var result witTypes.Result[witTypes.Unit, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, Error](witTypes.Unit{})
+	case 1:
+		var variant7 Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant7 = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant7 = MakeErrorSendFailure(value2)
+
+		case 2:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant7 = MakeErrorReceiveFailure(value3)
+
+		case 3:
+			value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant7 = MakeErrorProtocolError(value4)
+
+		case 4:
+			var option witTypes.Option[CloseInfo]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+
+				option = witTypes.None[CloseInfo]()
+			case 1:
+				value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4))))
+
+				option = witTypes.Some[CloseInfo](CloseInfo{uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))), value5})
+			default:
+				panic("unreachable")
+			}
+
+			variant7 = MakeErrorClosed(option)
+
+		case 5:
+			value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant7 = MakeErrorOther(value6)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Unit, Error](variant7)
+	default:
+		panic("unreachable")
+	}
+	result8 := result
+	return result8
+
+}
+
+//go:wasmimport golem:websocket/client@1.5.0 [async-lower][method]websocket-connection.receive
+func wasm_import_method_websocket_connection_receive(arg0 int32, arg1 uintptr) int32
+
+func (self *WebsocketConnection) Receive() witTypes.Result[Message, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (6 * 4), 4))
+
+	witAsync.SubtaskWait(uint32(wasm_import_method_websocket_connection_receive((self).Handle(), returnArea)))
+	var result witTypes.Result[Message, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		var variant Message
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeMessageText(value)
+
+		case 1:
+			value0 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeMessageBinary(value0)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Ok[Message, Error](variant)
+	case 1:
+		var variant7 Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant7 = MakeErrorConnectionFailure(value1)
+
+		case 1:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant7 = MakeErrorSendFailure(value2)
+
+		case 2:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant7 = MakeErrorReceiveFailure(value3)
+
+		case 3:
+			value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant7 = MakeErrorProtocolError(value4)
+
+		case 4:
+			var option witTypes.Option[CloseInfo]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+
+				option = witTypes.None[CloseInfo]()
+			case 1:
+				value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4))))
+
+				option = witTypes.Some[CloseInfo](CloseInfo{uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))), value5})
+			default:
+				panic("unreachable")
+			}
+
+			variant7 = MakeErrorClosed(option)
+
+		case 5:
+			value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant7 = MakeErrorOther(value6)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[Message, Error](variant7)
+	default:
+		panic("unreachable")
+	}
+
+	return result
+
+}
+
+//go:wasmimport golem:websocket/client@1.5.0 [async-lower][method]websocket-connection.receive-with-timeout
+func wasm_import_method_websocket_connection_receive_with_timeout(arg0 int32, arg1 int64, arg2 uintptr) int32
+
+func (self *WebsocketConnection) ReceiveWithTimeout(timeoutMs uint64) witTypes.Result[witTypes.Option[Message], Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (6 * 4), 4))
+
+	witAsync.SubtaskWait(uint32(wasm_import_method_websocket_connection_receive_with_timeout((self).Handle(), int64(timeoutMs), returnArea)))
+	var result witTypes.Result[witTypes.Option[Message], Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		var option witTypes.Option[Message]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+
+			option = witTypes.None[Message]()
+		case 1:
+			var variant Message
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+				value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				variant = MakeMessageText(value)
+
+			case 1:
+				value0 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				variant = MakeMessageBinary(value0)
+
+			default:
+				panic("unreachable")
+			}
+
+			option = witTypes.Some[Message](variant)
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Ok[witTypes.Option[Message], Error](option)
+	case 1:
+		var variant8 Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant8 = MakeErrorConnectionFailure(value1)
+
+		case 1:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant8 = MakeErrorSendFailure(value2)
+
+		case 2:
+			value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant8 = MakeErrorReceiveFailure(value3)
+
+		case 3:
+			value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant8 = MakeErrorProtocolError(value4)
+
+		case 4:
+			var option6 witTypes.Option[CloseInfo]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+
+				option6 = witTypes.None[CloseInfo]()
+			case 1:
+				value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4))))
+
+				option6 = witTypes.Some[CloseInfo](CloseInfo{uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))), value5})
+			default:
+				panic("unreachable")
+			}
+
+			variant8 = MakeErrorClosed(option6)
+
+		case 5:
+			value7 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant8 = MakeErrorOther(value7)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Option[Message], Error](variant8)
+	default:
+		panic("unreachable")
+	}
+
+	return result
+
+}
+
+//go:wasmimport golem:websocket/client@1.5.0 [method]websocket-connection.close
+func wasm_import_method_websocket_connection_close(arg0 int32, arg1 int32, arg2 int32, arg3 int32, arg4 uintptr, arg5 uint32, arg6 uintptr)
+
+func (self *WebsocketConnection) Close(code witTypes.Option[uint16], reason witTypes.Option[string]) witTypes.Result[witTypes.Unit, Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (6 * 4), 4))
+	var option int32
+	var option0 int32
+	switch code.Tag() {
+	case witTypes.OptionNone:
+
+		option = int32(0)
+		option0 = 0
+	case witTypes.OptionSome:
+		payload := code.Some()
+
+		option = int32(1)
+		option0 = int32(payload)
+	default:
+		panic("unreachable")
+	}
+	var option1 int32
+	var option2 uintptr
+	var option3 uint32
+	switch reason.Tag() {
+	case witTypes.OptionNone:
+
+		option1 = int32(0)
+		option2 = 0
+		option3 = 0
+	case witTypes.OptionSome:
+		payload := reason.Some()
+		utf8 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf8)
+
+		option1 = int32(1)
+		option2 = uintptr(utf8)
+		option3 = uint32(len(payload))
+	default:
+		panic("unreachable")
+	}
+	wasm_import_method_websocket_connection_close((self).Handle(), option, option0, option1, option2, option3, returnArea)
+	var result witTypes.Result[witTypes.Unit, Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, Error](witTypes.Unit{})
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorConnectionFailure(value)
+
+		case 1:
+			value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorSendFailure(value4)
+
+		case 2:
+			value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorReceiveFailure(value5)
+
+		case 3:
+			value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorProtocolError(value6)
+
+		case 4:
+			var option8 witTypes.Option[CloseInfo]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+
+				option8 = witTypes.None[CloseInfo]()
+			case 1:
+				value7 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4))))
+
+				option8 = witTypes.Some[CloseInfo](CloseInfo{uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))), value7})
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorClosed(option8)
+
+		case 5:
+			value9 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorOther(value9)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Unit, Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result10 := result
+	return result10
+
+}
diff --git a/sdks/go/golem/internal/wit/wasi_blobstore_blobstore/empty.s b/sdks/go/golem/internal/wit/wasi_blobstore_blobstore/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_blobstore_blobstore/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/wasi_blobstore_blobstore/wit_bindings.go b/sdks/go/golem/internal/wit/wasi_blobstore_blobstore/wit_bindings.go
new file mode 100644
index 0000000000..8016ec2aa2
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_blobstore_blobstore/wit_bindings.go
@@ -0,0 +1,226 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package wasi_blobstore_blobstore
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_blobstore_container"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_blobstore_types"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type Container = wasi_blobstore_container.Container
+type Error = string
+type ContainerName = string
+type ObjectId = wasi_blobstore_types.ObjectId
+
+//go:wasmimport wasi:blobstore/blobstore create-container
+func wasm_import_create_container(arg0 uintptr, arg1 uint32, arg2 uintptr)
+
+func CreateContainer(name string) witTypes.Result[*wasi_blobstore_container.Container, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	wasm_import_create_container(uintptr(utf8), uint32(len(name)), returnArea)
+	var result witTypes.Result[*wasi_blobstore_container.Container, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[*wasi_blobstore_container.Container, string](wasi_blobstore_container.ContainerFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Err[*wasi_blobstore_container.Container, string](value)
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:blobstore/blobstore get-container
+func wasm_import_get_container(arg0 uintptr, arg1 uint32, arg2 uintptr)
+
+func GetContainer(name string) witTypes.Result[*wasi_blobstore_container.Container, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	wasm_import_get_container(uintptr(utf8), uint32(len(name)), returnArea)
+	var result witTypes.Result[*wasi_blobstore_container.Container, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[*wasi_blobstore_container.Container, string](wasi_blobstore_container.ContainerFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Err[*wasi_blobstore_container.Container, string](value)
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:blobstore/blobstore delete-container
+func wasm_import_delete_container(arg0 uintptr, arg1 uint32, arg2 uintptr)
+
+func DeleteContainer(name string) witTypes.Result[witTypes.Unit, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	wasm_import_delete_container(uintptr(utf8), uint32(len(name)), returnArea)
+	var result witTypes.Result[witTypes.Unit, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, string](witTypes.Unit{})
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Err[witTypes.Unit, string](value)
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:blobstore/blobstore container-exists
+func wasm_import_container_exists(arg0 uintptr, arg1 uint32, arg2 uintptr)
+
+func ContainerExists(name string) witTypes.Result[bool, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	wasm_import_container_exists(uintptr(utf8), uint32(len(name)), returnArea)
+	var result witTypes.Result[bool, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[bool, string]((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) != 0))
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Err[bool, string](value)
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:blobstore/blobstore copy-object
+func wasm_import_copy_object(arg0 uintptr, arg1 uint32, arg2 uintptr, arg3 uint32, arg4 uintptr, arg5 uint32, arg6 uintptr, arg7 uint32, arg8 uintptr)
+
+func CopyObject(src wasi_blobstore_types.ObjectId, dest wasi_blobstore_types.ObjectId) witTypes.Result[witTypes.Unit, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData((src).Container))
+	pinner.Pin(utf8)
+	utf80 := unsafe.Pointer(unsafe.StringData((src).Object))
+	pinner.Pin(utf80)
+	utf81 := unsafe.Pointer(unsafe.StringData((dest).Container))
+	pinner.Pin(utf81)
+	utf82 := unsafe.Pointer(unsafe.StringData((dest).Object))
+	pinner.Pin(utf82)
+	wasm_import_copy_object(uintptr(utf8), uint32(len((src).Container)), uintptr(utf80), uint32(len((src).Object)), uintptr(utf81), uint32(len((dest).Container)), uintptr(utf82), uint32(len((dest).Object)), returnArea)
+	var result witTypes.Result[witTypes.Unit, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, string](witTypes.Unit{})
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Err[witTypes.Unit, string](value)
+	default:
+		panic("unreachable")
+	}
+	result3 := result
+	return result3
+
+}
+
+//go:wasmimport wasi:blobstore/blobstore move-object
+func wasm_import_move_object(arg0 uintptr, arg1 uint32, arg2 uintptr, arg3 uint32, arg4 uintptr, arg5 uint32, arg6 uintptr, arg7 uint32, arg8 uintptr)
+
+func MoveObject(src wasi_blobstore_types.ObjectId, dest wasi_blobstore_types.ObjectId) witTypes.Result[witTypes.Unit, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData((src).Container))
+	pinner.Pin(utf8)
+	utf80 := unsafe.Pointer(unsafe.StringData((src).Object))
+	pinner.Pin(utf80)
+	utf81 := unsafe.Pointer(unsafe.StringData((dest).Container))
+	pinner.Pin(utf81)
+	utf82 := unsafe.Pointer(unsafe.StringData((dest).Object))
+	pinner.Pin(utf82)
+	wasm_import_move_object(uintptr(utf8), uint32(len((src).Container)), uintptr(utf80), uint32(len((src).Object)), uintptr(utf81), uint32(len((dest).Container)), uintptr(utf82), uint32(len((dest).Object)), returnArea)
+	var result witTypes.Result[witTypes.Unit, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, string](witTypes.Unit{})
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Err[witTypes.Unit, string](value)
+	default:
+		panic("unreachable")
+	}
+	result3 := result
+	return result3
+
+}
diff --git a/sdks/go/golem/internal/wit/wasi_blobstore_container/empty.s b/sdks/go/golem/internal/wit/wasi_blobstore_container/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_blobstore_container/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/wasi_blobstore_container/wit_bindings.go b/sdks/go/golem/internal/wit/wasi_blobstore_container/wit_bindings.go
new file mode 100644
index 0000000000..6abb49764a
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_blobstore_container/wit_bindings.go
@@ -0,0 +1,434 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package wasi_blobstore_container
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_blobstore_types"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+//go:wasmimport wasi:blobstore/container [stream-new-0][method]container.list-objects
+func wasm_stream_new_string() uint64
+
+//go:wasmimport wasi:blobstore/container [async-lower][stream-read-0][method]container.list-objects
+func wasm_stream_read_string(handle int32, item unsafe.Pointer, count uint32) uint32
+
+//go:wasmimport wasi:blobstore/container [async-lower][stream-write-0][method]container.list-objects
+func wasm_stream_write_string(handle int32, item unsafe.Pointer, count uint32) uint32
+
+//go:wasmimport wasi:blobstore/container [stream-drop-readable-0][method]container.list-objects
+func wasm_stream_drop_readable_string(handle int32)
+
+//go:wasmimport wasi:blobstore/container [stream-drop-writable-0][method]container.list-objects
+func wasm_stream_drop_writable_string(handle int32)
+
+func wasm_stream_lift_string(src unsafe.Pointer) string {
+	value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), 4)))
+
+	return value
+}
+
+func wasm_stream_lower_string(
+	pinner *runtime.Pinner,
+	value string,
+	dst unsafe.Pointer,
+) func() {
+	utf8 := unsafe.Pointer(unsafe.StringData(value))
+	pinner.Pin(utf8)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(dst), 4)) = uint32(uint32(len(value)))
+	*(*uint32)(unsafe.Add(unsafe.Pointer(dst), 0)) = uint32(uintptr(uintptr(utf8)))
+
+	return func() {}
+}
+
+var wasm_stream_vtable_string = witTypes.StreamVtable[string]{
+	(2 * 4),
+	4,
+	wasm_stream_read_string,
+	wasm_stream_write_string,
+	nil,
+	nil,
+	wasm_stream_drop_readable_string,
+	wasm_stream_drop_writable_string,
+	wasm_stream_lift_string,
+	wasm_stream_lower_string,
+}
+
+func MakeStreamString() (*witTypes.StreamWriter[string], *witTypes.StreamReader[string]) {
+	pair := wasm_stream_new_string()
+	return witTypes.MakeStreamWriter[string](&wasm_stream_vtable_string, int32(pair>>32)),
+		witTypes.MakeStreamReader[string](&wasm_stream_vtable_string, int32(pair&0xFFFFFFFF))
+}
+
+func LiftStreamString(handle int32) *witTypes.StreamReader[string] {
+	return witTypes.MakeStreamReader[string](&wasm_stream_vtable_string, handle)
+}
+
+type ContainerMetadata = wasi_blobstore_types.ContainerMetadata
+type Error = string
+type IncomingValue = wasi_blobstore_types.IncomingValue
+type ObjectMetadata = wasi_blobstore_types.ObjectMetadata
+type ObjectName = string
+type OutgoingValue = wasi_blobstore_types.OutgoingValue
+
+//go:wasmimport wasi:blobstore/container [resource-drop]container
+func resourceDropContainer(handle int32)
+
+// this defines the `container` resource
+type Container struct {
+	handle *witRuntime.Handle
+}
+
+func (self *Container) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *Container) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *Container) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *Container) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropContainer(handle)
+	}
+}
+
+func ContainerFromOwnHandle(handleValue int32) *Container {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &Container{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropContainer(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func ContainerFromBorrowHandle(handleValue int32) *Container {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &Container{handle}
+}
+
+//go:wasmimport wasi:blobstore/container [method]container.name
+func wasm_import_method_container_name(arg0 int32, arg1 uintptr)
+
+func (self *Container) Name() witTypes.Result[string, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_method_container_name((self).Handle(), returnArea)
+	var result witTypes.Result[string, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Ok[string, string](value)
+	case 1:
+		value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Err[string, string](value0)
+	default:
+		panic("unreachable")
+	}
+	result1 := result
+	return result1
+
+}
+
+//go:wasmimport wasi:blobstore/container [method]container.info
+func wasm_import_method_container_info(arg0 int32, arg1 uintptr)
+
+func (self *Container) Info() witTypes.Result[wasi_blobstore_types.ContainerMetadata, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (16 + 2*4), 8))
+	wasm_import_method_container_info((self).Handle(), returnArea)
+	var result witTypes.Result[wasi_blobstore_types.ContainerMetadata, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		result = witTypes.Ok[wasi_blobstore_types.ContainerMetadata, string](wasi_blobstore_types.ContainerMetadata{value, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4))))})
+	case 1:
+		value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		result = witTypes.Err[wasi_blobstore_types.ContainerMetadata, string](value0)
+	default:
+		panic("unreachable")
+	}
+	result1 := result
+	return result1
+
+}
+
+//go:wasmimport wasi:blobstore/container [method]container.get-data
+func wasm_import_method_container_get_data(arg0 int32, arg1 uintptr, arg2 uint32, arg3 int64, arg4 int64, arg5 uintptr)
+
+func (self *Container) GetData(name string, start uint64, end uint64) witTypes.Result[*wasi_blobstore_types.IncomingValue, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	wasm_import_method_container_get_data((self).Handle(), uintptr(utf8), uint32(len(name)), int64(start), int64(end), returnArea)
+	var result witTypes.Result[*wasi_blobstore_types.IncomingValue, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[*wasi_blobstore_types.IncomingValue, string](wasi_blobstore_types.IncomingValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Err[*wasi_blobstore_types.IncomingValue, string](value)
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:blobstore/container [method]container.write-data
+func wasm_import_method_container_write_data(arg0 int32, arg1 uintptr, arg2 uint32, arg3 int32, arg4 uintptr)
+
+func (self *Container) WriteData(name string, data *wasi_blobstore_types.OutgoingValue) witTypes.Result[witTypes.Unit, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	wasm_import_method_container_write_data((self).Handle(), uintptr(utf8), uint32(len(name)), (data).Handle(), returnArea)
+	var result witTypes.Result[witTypes.Unit, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, string](witTypes.Unit{})
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Err[witTypes.Unit, string](value)
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:blobstore/container [method]container.list-objects
+func wasm_import_method_container_list_objects(arg0 int32, arg1 uintptr)
+
+func (self *Container) ListObjects() witTypes.Result[*witTypes.StreamReader[string], string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_method_container_list_objects((self).Handle(), returnArea)
+	var result witTypes.Result[*witTypes.StreamReader[string], string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[*witTypes.StreamReader[string], string](LiftStreamString(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Err[*witTypes.StreamReader[string], string](value)
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:blobstore/container [method]container.delete-object
+func wasm_import_method_container_delete_object(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
+
+func (self *Container) DeleteObject(name string) witTypes.Result[witTypes.Unit, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	wasm_import_method_container_delete_object((self).Handle(), uintptr(utf8), uint32(len(name)), returnArea)
+	var result witTypes.Result[witTypes.Unit, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, string](witTypes.Unit{})
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Err[witTypes.Unit, string](value)
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:blobstore/container [method]container.delete-objects
+func wasm_import_method_container_delete_objects(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
+
+func (self *Container) DeleteObjects(names []string) witTypes.Result[witTypes.Unit, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	slice := names
+	length := uint32(len(slice))
+	result := witRuntime.Allocate(pinner, uintptr(length*(2*4)), 4)
+	for index, element := range slice {
+		base := unsafe.Add(result, index*(2*4))
+		utf8 := unsafe.Pointer(unsafe.StringData(element))
+		pinner.Pin(utf8)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8)))
+
+	}
+
+	wasm_import_method_container_delete_objects((self).Handle(), uintptr(result), length, returnArea)
+	var result0 witTypes.Result[witTypes.Unit, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result0 = witTypes.Ok[witTypes.Unit, string](witTypes.Unit{})
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result0 = witTypes.Err[witTypes.Unit, string](value)
+	default:
+		panic("unreachable")
+	}
+	result1 := result0
+	return result1
+
+}
+
+//go:wasmimport wasi:blobstore/container [method]container.has-object
+func wasm_import_method_container_has_object(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
+
+func (self *Container) HasObject(name string) witTypes.Result[bool, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	wasm_import_method_container_has_object((self).Handle(), uintptr(utf8), uint32(len(name)), returnArea)
+	var result witTypes.Result[bool, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[bool, string]((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) != 0))
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Err[bool, string](value)
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:blobstore/container [method]container.object-info
+func wasm_import_method_container_object_info(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
+
+func (self *Container) ObjectInfo(name string) witTypes.Result[wasi_blobstore_types.ObjectMetadata, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (24 + 4*4), 8))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	wasm_import_method_container_object_info((self).Handle(), uintptr(utf8), uint32(len(name)), returnArea)
+	var result witTypes.Result[wasi_blobstore_types.ObjectMetadata, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+		value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 3*4))))
+
+		result = witTypes.Ok[wasi_blobstore_types.ObjectMetadata, string](wasi_blobstore_types.ObjectMetadata{value, value0, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 4*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 4*4))))})
+	case 1:
+		value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))
+
+		result = witTypes.Err[wasi_blobstore_types.ObjectMetadata, string](value1)
+	default:
+		panic("unreachable")
+	}
+	result2 := result
+	return result2
+
+}
+
+//go:wasmimport wasi:blobstore/container [method]container.clear
+func wasm_import_method_container_clear(arg0 int32, arg1 uintptr)
+
+func (self *Container) Clear() witTypes.Result[witTypes.Unit, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_method_container_clear((self).Handle(), returnArea)
+	var result witTypes.Result[witTypes.Unit, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, string](witTypes.Unit{})
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Err[witTypes.Unit, string](value)
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
diff --git a/sdks/go/golem/internal/wit/wasi_blobstore_types/empty.s b/sdks/go/golem/internal/wit/wasi_blobstore_types/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_blobstore_types/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/wasi_blobstore_types/wit_bindings.go b/sdks/go/golem/internal/wit/wasi_blobstore_types/wit_bindings.go
new file mode 100644
index 0000000000..3dbf307a79
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_blobstore_types/wit_bindings.go
@@ -0,0 +1,312 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package wasi_blobstore_types
+
+import (
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+//go:wasmimport wasi:blobstore/types [stream-new-0][method]outgoing-value.outgoing-value-write-body
+func wasm_stream_new_u8() uint64
+
+//go:wasmimport wasi:blobstore/types [async-lower][stream-read-0][method]outgoing-value.outgoing-value-write-body
+func wasm_stream_read_u8(handle int32, item unsafe.Pointer, count uint32) uint32
+
+//go:wasmimport wasi:blobstore/types [async-lower][stream-write-0][method]outgoing-value.outgoing-value-write-body
+func wasm_stream_write_u8(handle int32, item unsafe.Pointer, count uint32) uint32
+
+//go:wasmimport wasi:blobstore/types [stream-drop-readable-0][method]outgoing-value.outgoing-value-write-body
+func wasm_stream_drop_readable_u8(handle int32)
+
+//go:wasmimport wasi:blobstore/types [stream-drop-writable-0][method]outgoing-value.outgoing-value-write-body
+func wasm_stream_drop_writable_u8(handle int32)
+
+var wasm_stream_vtable_u8 = witTypes.StreamVtable[uint8]{
+	1,
+	1,
+	wasm_stream_read_u8,
+	wasm_stream_write_u8,
+	nil,
+	nil,
+	wasm_stream_drop_readable_u8,
+	wasm_stream_drop_writable_u8,
+	nil,
+	nil,
+}
+
+func MakeStreamU8() (*witTypes.StreamWriter[uint8], *witTypes.StreamReader[uint8]) {
+	pair := wasm_stream_new_u8()
+	return witTypes.MakeStreamWriter[uint8](&wasm_stream_vtable_u8, int32(pair>>32)),
+		witTypes.MakeStreamReader[uint8](&wasm_stream_vtable_u8, int32(pair&0xFFFFFFFF))
+}
+
+func LiftStreamU8(handle int32) *witTypes.StreamReader[uint8] {
+	return witTypes.MakeStreamReader[uint8](&wasm_stream_vtable_u8, handle)
+}
+
+// name of a container, a collection of objects.
+// The container name may be any valid UTF-8 string.
+type ContainerName = string
+
+// name of an object within a container
+// The object name may be any valid UTF-8 string.
+type ObjectName = string
+
+// TODO: define timestamp to include seconds since
+// Unix epoch and nanoseconds
+// https://github.com/WebAssembly/wasi-blob-store/issues/7
+type Timestamp = uint64
+
+// size of an object, in bytes
+type ObjectSize = uint64
+type Error = string
+
+// information about a container
+type ContainerMetadata struct {
+	// the container's name
+	Name string
+	// date and time container was created
+	CreatedAt uint64
+}
+
+// information about an object
+type ObjectMetadata struct {
+	// the object's name
+	Name string
+	// the object's parent container
+	Container string
+	// date and time the object was created
+	CreatedAt uint64
+	// size of the object, in bytes
+	Size uint64
+}
+
+// identifier for an object that includes its container name
+type ObjectId struct {
+	Container string
+	Object    string
+}
+
+//go:wasmimport wasi:blobstore/types [resource-drop]outgoing-value
+func resourceDropOutgoingValue(handle int32)
+
+// A data blob value. The value can be of any type that can be represented
+// in a byte array.
+// Soon: switch to `resource value { ... }`
+type OutgoingValue struct {
+	handle *witRuntime.Handle
+}
+
+func (self *OutgoingValue) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *OutgoingValue) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *OutgoingValue) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *OutgoingValue) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropOutgoingValue(handle)
+	}
+}
+
+func OutgoingValueFromOwnHandle(handleValue int32) *OutgoingValue {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &OutgoingValue{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropOutgoingValue(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func OutgoingValueFromBorrowHandle(handleValue int32) *OutgoingValue {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &OutgoingValue{handle}
+}
+
+//go:wasmimport wasi:blobstore/types [resource-drop]incoming-value
+func resourceDropIncomingValue(handle int32)
+
+// A incoming-value is a wrapper around a value.
+//
+// The incoming-value provides two ways to consume the value:
+//  1. `incoming-value-consume-sync` consumes the value synchronously and returns the
+//     value as a list of bytes.
+//  2. `incoming-value-consume-async` consumes the value asynchronously and returns the
+//     value as a `stream<u8>`.
+//
+// Soon: switch to `resource incoming-value { ... }`
+type IncomingValue struct {
+	handle *witRuntime.Handle
+}
+
+func (self *IncomingValue) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *IncomingValue) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *IncomingValue) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *IncomingValue) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropIncomingValue(handle)
+	}
+}
+
+func IncomingValueFromOwnHandle(handleValue int32) *IncomingValue {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &IncomingValue{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropIncomingValue(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func IncomingValueFromBorrowHandle(handleValue int32) *IncomingValue {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &IncomingValue{handle}
+}
+
+//go:wasmimport wasi:blobstore/types [static]outgoing-value.new-outgoing-value
+func wasm_import_static_outgoing_value_new_outgoing_value() int32
+
+func OutgoingValueNewOutgoingValue() *OutgoingValue {
+
+	result := wasm_import_static_outgoing_value_new_outgoing_value()
+	return OutgoingValueFromOwnHandle(int32(uintptr(result)))
+
+}
+
+//go:wasmimport wasi:blobstore/types [method]outgoing-value.outgoing-value-write-body
+func wasm_import_method_outgoing_value_outgoing_value_write_body(arg0 int32, arg1 int32) int32
+
+func (self *OutgoingValue) OutgoingValueWriteBody(data *witTypes.StreamReader[uint8]) witTypes.Result[witTypes.Unit, witTypes.Unit] {
+
+	result := wasm_import_method_outgoing_value_outgoing_value_write_body((self).Handle(), (data).TakeHandle())
+	var result0 witTypes.Result[witTypes.Unit, witTypes.Unit]
+	switch result {
+	case 0:
+
+		result0 = witTypes.Ok[witTypes.Unit, witTypes.Unit](witTypes.Unit{})
+	case 1:
+
+		result0 = witTypes.Err[witTypes.Unit, witTypes.Unit](witTypes.Unit{})
+	default:
+		panic("unreachable")
+	}
+	return result0
+
+}
+
+//go:wasmimport wasi:blobstore/types [method]incoming-value.incoming-value-consume-sync
+func wasm_import_method_incoming_value_incoming_value_consume_sync(arg0 int32, arg1 uintptr)
+
+func (self *IncomingValue) IncomingValueConsumeSync() witTypes.Result[[]uint8, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_method_incoming_value_incoming_value_consume_sync((self).Handle(), returnArea)
+	var result witTypes.Result[[]uint8, string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		value := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Ok[[]uint8, string](value)
+	case 1:
+		value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Err[[]uint8, string](value0)
+	default:
+		panic("unreachable")
+	}
+	result1 := result
+	return result1
+
+}
+
+//go:wasmimport wasi:blobstore/types [method]incoming-value.incoming-value-consume-async
+func wasm_import_method_incoming_value_incoming_value_consume_async(arg0 int32, arg1 uintptr)
+
+func (self *IncomingValue) IncomingValueConsumeAsync() witTypes.Result[*witTypes.StreamReader[uint8], string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_method_incoming_value_incoming_value_consume_async((self).Handle(), returnArea)
+	var result witTypes.Result[*witTypes.StreamReader[uint8], string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[*witTypes.StreamReader[uint8], string](LiftStreamU8(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Err[*witTypes.StreamReader[uint8], string](value)
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:blobstore/types [method]incoming-value.size
+func wasm_import_method_incoming_value_size(arg0 int32) int64
+
+func (self *IncomingValue) Size() uint64 {
+
+	result := wasm_import_method_incoming_value_size((self).Handle())
+	return uint64(result)
+
+}
diff --git a/sdks/go/golem/internal/wit/wasi_cli_0_3_0_environment/empty.s b/sdks/go/golem/internal/wit/wasi_cli_0_3_0_environment/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_cli_0_3_0_environment/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/wasi_cli_0_3_0_environment/wit_bindings.go b/sdks/go/golem/internal/wit/wasi_cli_0_3_0_environment/wit_bindings.go
new file mode 100644
index 0000000000..9b2ba9fdea
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_cli_0_3_0_environment/wit_bindings.go
@@ -0,0 +1,110 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package wasi_cli_0_3_0_environment
+
+import (
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+//go:wasmimport wasi:cli/environment@0.3.0 get-environment
+func wasm_import_get_environment(arg0 uintptr)
+
+func GetEnvironment() []witTypes.Tuple2[string, string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	wasm_import_get_environment(returnArea)
+	result := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)))), index*(4*4))
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+		value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+		result = append(result, witTypes.Tuple2[string, string]{value, value0})
+	}
+
+	result1 := result
+	return result1
+
+}
+
+//go:wasmimport wasi:cli/environment@0.3.0 get-arguments
+func wasm_import_get_arguments(arg0 uintptr)
+
+func GetArguments() []string {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	wasm_import_get_arguments(returnArea)
+	result := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)))), index*(2*4))
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+		result = append(result, value)
+	}
+
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:cli/environment@0.3.0 get-initial-cwd
+func wasm_import_get_initial_cwd(arg0 uintptr)
+
+func GetInitialCwd() witTypes.Option[string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_get_initial_cwd(returnArea)
+	var option witTypes.Option[string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[string]()
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		option = witTypes.Some[string](value)
+	default:
+		panic("unreachable")
+	}
+	result := option
+	return result
+
+}
diff --git a/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_system_clock/empty.s b/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_system_clock/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_system_clock/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_system_clock/wit_bindings.go b/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_system_clock/wit_bindings.go
new file mode 100644
index 0000000000..9fbc7c7a62
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_system_clock/wit_bindings.go
@@ -0,0 +1,85 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package wasi_clocks_0_3_0_system_clock
+
+import (
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	"runtime"
+	"unsafe"
+)
+
+type Duration = uint64
+
+// An "instant", or "exact time", is a point in time without regard to any
+// time zone: just the time since a particular external reference point,
+// often called an "epoch".
+//
+// Here, the epoch is 1970-01-01T00:00:00Z, also known as
+// [POSIX's Seconds Since the Epoch], also known as [Unix Time].
+//
+// Note that even if the seconds field is negative, incrementing
+// nanoseconds always represents moving forwards in time.
+// For example, `{ -1 seconds, 999999999 nanoseconds }` represents the
+// instant one nanosecond before the epoch.
+// For more on various different ways to represent time, see
+// https://tc39.es/proposal-temporal/docs/timezone.html
+//
+// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
+// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
+type Instant struct {
+	Seconds     int64
+	Nanoseconds uint32
+}
+
+//go:wasmimport wasi:clocks/system-clock@0.3.0 now
+func wasm_import_now(arg0 uintptr)
+
+func Now() Instant {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 16, 8))
+	wasm_import_now(returnArea)
+	result := Instant{*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 0)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))}
+	return result
+
+}
+
+//go:wasmimport wasi:clocks/system-clock@0.3.0 get-resolution
+func wasm_import_get_resolution() int64
+
+func GetResolution() uint64 {
+
+	result := wasm_import_get_resolution()
+	return uint64(result)
+
+}
diff --git a/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_types/empty.s b/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_types/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_types/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_types/wit_bindings.go b/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_types/wit_bindings.go
new file mode 100644
index 0000000000..dd8f7b806c
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_types/wit_bindings.go
@@ -0,0 +1,37 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package wasi_clocks_0_3_0_types
+
+import ()
+
+// A duration of time, in nanoseconds.
+type Duration = uint64
diff --git a/sdks/go/golem/internal/wit/wasi_config_store/empty.s b/sdks/go/golem/internal/wit/wasi_config_store/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_config_store/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/wasi_config_store/wit_bindings.go b/sdks/go/golem/internal/wit/wasi_config_store/wit_bindings.go
new file mode 100644
index 0000000000..c748e1a84d
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_config_store/wit_bindings.go
@@ -0,0 +1,185 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package wasi_config_store
+
+import (
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+const (
+	// This indicates an error from an "upstream" config source.
+	// As this could be almost _anything_ (such as Vault, Kubernetes ConfigMaps, KeyValue buckets, etc),
+	// the error message is a string.
+	ErrorUpstream uint8 = 0
+	// This indicates an error from an I/O operation.
+	// As this could be almost _anything_ (such as a file read, network connection, etc),
+	// the error message is a string.
+	// Depending on how this ends up being consumed,
+	// we may consider moving this to use the `wasi:io/error` type instead.
+	// For simplicity right now in supporting multiple implementations, it is being left as a string.
+	ErrorIo uint8 = 1
+)
+
+// An error type that encapsulates the different errors that can occur fetching configuration values.
+type Error struct {
+	tag   uint8
+	value any
+}
+
+func (self Error) Tag() uint8 {
+	return self.tag
+}
+
+func (self Error) Upstream() string {
+	if self.tag != ErrorUpstream {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+func (self Error) Io() string {
+	if self.tag != ErrorIo {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+
+func MakeErrorUpstream(value string) Error {
+	return Error{ErrorUpstream, value}
+}
+func MakeErrorIo(value string) Error {
+	return Error{ErrorIo, value}
+}
+
+//go:wasmimport wasi:config/store@0.2.0-draft get
+func wasm_import_get(arg0 uintptr, arg1 uint32, arg2 uintptr)
+
+func Get(key string) witTypes.Result[witTypes.Option[string], Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(key))
+	pinner.Pin(utf8)
+	wasm_import_get(uintptr(utf8), uint32(len(key)), returnArea)
+	var result witTypes.Result[witTypes.Option[string], Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		var option witTypes.Option[string]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+
+			option = witTypes.None[string]()
+		case 1:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			option = witTypes.Some[string](value)
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Ok[witTypes.Option[string], Error](option)
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorUpstream(value0)
+
+		case 1:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorIo(value1)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Option[string], Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result2 := result
+	return result2
+
+}
+
+//go:wasmimport wasi:config/store@0.2.0-draft get-all
+func wasm_import_get_all(arg0 uintptr)
+
+func GetAll() witTypes.Result[[]witTypes.Tuple2[string, string], Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	wasm_import_get_all(returnArea)
+	var result3 witTypes.Result[[]witTypes.Tuple2[string, string], Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		result := make([]witTypes.Tuple2[string, string], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(4*4))
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+			value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+			result = append(result, witTypes.Tuple2[string, string]{value, value0})
+		}
+
+		result3 = witTypes.Ok[[]witTypes.Tuple2[string, string], Error](result)
+	case 1:
+		var variant Error
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+			value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorUpstream(value1)
+
+		case 1:
+			value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeErrorIo(value2)
+
+		default:
+			panic("unreachable")
+		}
+
+		result3 = witTypes.Err[[]witTypes.Tuple2[string, string], Error](variant)
+	default:
+		panic("unreachable")
+	}
+	result4 := result3
+	return result4
+
+}
diff --git a/sdks/go/golem/internal/wit/wasi_http_0_3_0_client/empty.s b/sdks/go/golem/internal/wit/wasi_http_0_3_0_client/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_http_0_3_0_client/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/wasi_http_0_3_0_client/wit_bindings.go b/sdks/go/golem/internal/wit/wasi_http_0_3_0_client/wit_bindings.go
new file mode 100644
index 0000000000..1d0a8a9e81
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_http_0_3_0_client/wit_bindings.go
@@ -0,0 +1,483 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package wasi_http_0_3_0_client
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_http_0_3_0_types"
+	witAsync "go.bytecodealliance.org/pkg/wit/async"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type Request = wasi_http_0_3_0_types.Request
+type Response = wasi_http_0_3_0_types.Response
+type ErrorCode = wasi_http_0_3_0_types.ErrorCode
+
+//go:wasmimport wasi:http/client@0.3.0 [async-lower]send
+func wasm_import_send(arg0 int32, arg1 uintptr) int32
+
+func Send(request *wasi_http_0_3_0_types.Request) witTypes.Result[*wasi_http_0_3_0_types.Response, wasi_http_0_3_0_types.ErrorCode] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (24 + 4*4), 8))
+
+	witAsync.SubtaskWait(uint32(wasm_import_send((request).TakeHandle(), returnArea)))
+	var result witTypes.Result[*wasi_http_0_3_0_types.Response, wasi_http_0_3_0_types.ErrorCode]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[*wasi_http_0_3_0_types.Response, wasi_http_0_3_0_types.ErrorCode](wasi_http_0_3_0_types.ResponseFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))))
+	case 1:
+		var variant wasi_http_0_3_0_types.ErrorCode
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
+		case 0:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeDnsTimeout()
+
+		case 1:
+			var option witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+			case 0:
+
+				option = witTypes.None[string]()
+			case 1:
+				value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4))))
+
+				option = witTypes.Some[string](value)
+			default:
+				panic("unreachable")
+			}
+			var option0 witTypes.Option[uint16]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 3*4)))) {
+			case 0:
+
+				option0 = witTypes.None[uint16]()
+			case 1:
+
+				option0 = witTypes.Some[uint16](uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (18 + 3*4))))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeDnsError(wasi_http_0_3_0_types.DnsErrorPayload{option, option0})
+
+		case 2:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeDestinationNotFound()
+
+		case 3:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeDestinationUnavailable()
+
+		case 4:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeDestinationIpProhibited()
+
+		case 5:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeDestinationIpUnroutable()
+
+		case 6:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeConnectionRefused()
+
+		case 7:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeConnectionTerminated()
+
+		case 8:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeConnectionTimeout()
+
+		case 9:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeConnectionReadTimeout()
+
+		case 10:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeConnectionWriteTimeout()
+
+		case 11:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeConnectionLimitReached()
+
+		case 12:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeTlsProtocolError()
+
+		case 13:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeTlsCertificateError()
+
+		case 14:
+			var option1 witTypes.Option[uint8]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+			case 0:
+
+				option1 = witTypes.None[uint8]()
+			case 1:
+
+				option1 = witTypes.Some[uint8](uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 17)))))
+			default:
+				panic("unreachable")
+			}
+			var option3 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 1*4)))) {
+			case 0:
+
+				option3 = witTypes.None[string]()
+			case 1:
+				value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 3*4))))
+
+				option3 = witTypes.Some[string](value2)
+			default:
+				panic("unreachable")
+			}
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeTlsAlertReceived(wasi_http_0_3_0_types.TlsAlertReceivedPayload{option1, option3})
+
+		case 15:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpRequestDenied()
+
+		case 16:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpRequestLengthRequired()
+
+		case 17:
+			var option4 witTypes.Option[uint64]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+			case 0:
+
+				option4 = witTypes.None[uint64]()
+			case 1:
+
+				option4 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 24))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpRequestBodySize(option4)
+
+		case 18:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpRequestMethodInvalid()
+
+		case 19:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpRequestUriInvalid()
+
+		case 20:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpRequestUriTooLong()
+
+		case 21:
+			var option5 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+			case 0:
+
+				option5 = witTypes.None[uint32]()
+			case 1:
+
+				option5 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 20))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpRequestHeaderSectionSize(option5)
+
+		case 22:
+			var option9 witTypes.Option[wasi_http_0_3_0_types.FieldSizePayload]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+			case 0:
+
+				option9 = witTypes.None[wasi_http_0_3_0_types.FieldSizePayload]()
+			case 1:
+				var option7 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 1*4)))) {
+				case 0:
+
+					option7 = witTypes.None[string]()
+				case 1:
+					value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 3*4))))
+
+					option7 = witTypes.Some[string](value6)
+				default:
+					panic("unreachable")
+				}
+				var option8 witTypes.Option[uint32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 4*4)))) {
+				case 0:
+
+					option8 = witTypes.None[uint32]()
+				case 1:
+
+					option8 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (20 + 4*4)))))
+				default:
+					panic("unreachable")
+				}
+
+				option9 = witTypes.Some[wasi_http_0_3_0_types.FieldSizePayload](wasi_http_0_3_0_types.FieldSizePayload{option7, option8})
+			default:
+				panic("unreachable")
+			}
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpRequestHeaderSize(option9)
+
+		case 23:
+			var option10 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+			case 0:
+
+				option10 = witTypes.None[uint32]()
+			case 1:
+
+				option10 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 20))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpRequestTrailerSectionSize(option10)
+
+		case 24:
+			var option12 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+			case 0:
+
+				option12 = witTypes.None[string]()
+			case 1:
+				value11 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4))))
+
+				option12 = witTypes.Some[string](value11)
+			default:
+				panic("unreachable")
+			}
+			var option13 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 3*4)))) {
+			case 0:
+
+				option13 = witTypes.None[uint32]()
+			case 1:
+
+				option13 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (20 + 3*4)))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpRequestTrailerSize(wasi_http_0_3_0_types.FieldSizePayload{option12, option13})
+
+		case 25:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpResponseIncomplete()
+
+		case 26:
+			var option14 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+			case 0:
+
+				option14 = witTypes.None[uint32]()
+			case 1:
+
+				option14 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 20))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpResponseHeaderSectionSize(option14)
+
+		case 27:
+			var option16 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+			case 0:
+
+				option16 = witTypes.None[string]()
+			case 1:
+				value15 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4))))
+
+				option16 = witTypes.Some[string](value15)
+			default:
+				panic("unreachable")
+			}
+			var option17 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 3*4)))) {
+			case 0:
+
+				option17 = witTypes.None[uint32]()
+			case 1:
+
+				option17 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (20 + 3*4)))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpResponseHeaderSize(wasi_http_0_3_0_types.FieldSizePayload{option16, option17})
+
+		case 28:
+			var option18 witTypes.Option[uint64]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+			case 0:
+
+				option18 = witTypes.None[uint64]()
+			case 1:
+
+				option18 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 24))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpResponseBodySize(option18)
+
+		case 29:
+			var option19 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+			case 0:
+
+				option19 = witTypes.None[uint32]()
+			case 1:
+
+				option19 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 20))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpResponseTrailerSectionSize(option19)
+
+		case 30:
+			var option21 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+			case 0:
+
+				option21 = witTypes.None[string]()
+			case 1:
+				value20 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4))))
+
+				option21 = witTypes.Some[string](value20)
+			default:
+				panic("unreachable")
+			}
+			var option22 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 3*4)))) {
+			case 0:
+
+				option22 = witTypes.None[uint32]()
+			case 1:
+
+				option22 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (20 + 3*4)))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpResponseTrailerSize(wasi_http_0_3_0_types.FieldSizePayload{option21, option22})
+
+		case 31:
+			var option24 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+			case 0:
+
+				option24 = witTypes.None[string]()
+			case 1:
+				value23 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4))))
+
+				option24 = witTypes.Some[string](value23)
+			default:
+				panic("unreachable")
+			}
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpResponseTransferCoding(option24)
+
+		case 32:
+			var option26 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+			case 0:
+
+				option26 = witTypes.None[string]()
+			case 1:
+				value25 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4))))
+
+				option26 = witTypes.Some[string](value25)
+			default:
+				panic("unreachable")
+			}
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpResponseContentCoding(option26)
+
+		case 33:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpResponseTimeout()
+
+		case 34:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpUpgradeFailed()
+
+		case 35:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeHttpProtocolError()
+
+		case 36:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeLoopDetected()
+
+		case 37:
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeConfigurationError()
+
+		case 38:
+			var option28 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
+			case 0:
+
+				option28 = witTypes.None[string]()
+			case 1:
+				value27 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (16 + 2*4))))
+
+				option28 = witTypes.Some[string](value27)
+			default:
+				panic("unreachable")
+			}
+
+			variant = wasi_http_0_3_0_types.MakeErrorCodeInternalError(option28)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[*wasi_http_0_3_0_types.Response, wasi_http_0_3_0_types.ErrorCode](variant)
+	default:
+		panic("unreachable")
+	}
+
+	return result
+
+}
diff --git a/sdks/go/golem/internal/wit/wasi_http_0_3_0_types/empty.s b/sdks/go/golem/internal/wit/wasi_http_0_3_0_types/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_http_0_3_0_types/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/wasi_http_0_3_0_types/wit_bindings.go b/sdks/go/golem/internal/wit/wasi_http_0_3_0_types/wit_bindings.go
new file mode 100644
index 0000000000..025223d33c
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_http_0_3_0_types/wit_bindings.go
@@ -0,0 +1,4061 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package wasi_http_0_3_0_types
+
+import (
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+//go:wasmimport wasi:http/types@0.3.0 [stream-new-0][static]request.new
+func wasm_stream_new_u8() uint64
+
+//go:wasmimport wasi:http/types@0.3.0 [async-lower][stream-read-0][static]request.new
+func wasm_stream_read_u8(handle int32, item unsafe.Pointer, count uint32) uint32
+
+//go:wasmimport wasi:http/types@0.3.0 [async-lower][stream-write-0][static]request.new
+func wasm_stream_write_u8(handle int32, item unsafe.Pointer, count uint32) uint32
+
+//go:wasmimport wasi:http/types@0.3.0 [stream-drop-readable-0][static]request.new
+func wasm_stream_drop_readable_u8(handle int32)
+
+//go:wasmimport wasi:http/types@0.3.0 [stream-drop-writable-0][static]request.new
+func wasm_stream_drop_writable_u8(handle int32)
+
+var wasm_stream_vtable_u8 = witTypes.StreamVtable[uint8]{
+	1,
+	1,
+	wasm_stream_read_u8,
+	wasm_stream_write_u8,
+	nil,
+	nil,
+	wasm_stream_drop_readable_u8,
+	wasm_stream_drop_writable_u8,
+	nil,
+	nil,
+}
+
+func MakeStreamU8() (*witTypes.StreamWriter[uint8], *witTypes.StreamReader[uint8]) {
+	pair := wasm_stream_new_u8()
+	return witTypes.MakeStreamWriter[uint8](&wasm_stream_vtable_u8, int32(pair>>32)),
+		witTypes.MakeStreamReader[uint8](&wasm_stream_vtable_u8, int32(pair&0xFFFFFFFF))
+}
+
+func LiftStreamU8(handle int32) *witTypes.StreamReader[uint8] {
+	return witTypes.MakeStreamReader[uint8](&wasm_stream_vtable_u8, handle)
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [future-new-1][static]request.new
+func wasm_future_new_result_option_fields_error_code() uint64
+
+//go:wasmimport wasi:http/types@0.3.0 [async-lower][future-read-1][static]request.new
+func wasm_future_read_result_option_fields_error_code(handle int32, item unsafe.Pointer) uint32
+
+//go:wasmimport wasi:http/types@0.3.0 [async-lower][future-write-1][static]request.new
+func wasm_future_write_result_option_fields_error_code(handle int32, item unsafe.Pointer) uint32
+
+//go:wasmimport wasi:http/types@0.3.0 [future-drop-readable-1][static]request.new
+func wasm_future_drop_readable_result_option_fields_error_code(handle int32)
+
+//go:wasmimport wasi:http/types@0.3.0 [future-drop-writable-1][static]request.new
+func wasm_future_drop_writable_result_option_fields_error_code(handle int32)
+
+func wasm_future_lift_result_option_fields_error_code(src unsafe.Pointer) witTypes.Result[witTypes.Option[*Fields], ErrorCode] {
+	var result witTypes.Result[witTypes.Option[*Fields], ErrorCode]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 0))) {
+	case 0:
+		var option witTypes.Option[*Fields]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 8))) {
+		case 0:
+
+			option = witTypes.None[*Fields]()
+		case 1:
+
+			option = witTypes.Some[*Fields](FieldsFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(src), 12))))))
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Ok[witTypes.Option[*Fields], ErrorCode](option)
+	case 1:
+		var variant ErrorCode
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 8))) {
+		case 0:
+
+			variant = MakeErrorCodeDnsTimeout()
+
+		case 1:
+			var option0 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option0 = witTypes.None[string]()
+			case 1:
+				value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4))))
+
+				option0 = witTypes.Some[string](value)
+			default:
+				panic("unreachable")
+			}
+			var option1 witTypes.Option[uint16]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 3*4)))) {
+			case 0:
+
+				option1 = witTypes.None[uint16]()
+			case 1:
+
+				option1 = witTypes.Some[uint16](uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (18 + 3*4))))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeDnsError(DnsErrorPayload{option0, option1})
+
+		case 2:
+
+			variant = MakeErrorCodeDestinationNotFound()
+
+		case 3:
+
+			variant = MakeErrorCodeDestinationUnavailable()
+
+		case 4:
+
+			variant = MakeErrorCodeDestinationIpProhibited()
+
+		case 5:
+
+			variant = MakeErrorCodeDestinationIpUnroutable()
+
+		case 6:
+
+			variant = MakeErrorCodeConnectionRefused()
+
+		case 7:
+
+			variant = MakeErrorCodeConnectionTerminated()
+
+		case 8:
+
+			variant = MakeErrorCodeConnectionTimeout()
+
+		case 9:
+
+			variant = MakeErrorCodeConnectionReadTimeout()
+
+		case 10:
+
+			variant = MakeErrorCodeConnectionWriteTimeout()
+
+		case 11:
+
+			variant = MakeErrorCodeConnectionLimitReached()
+
+		case 12:
+
+			variant = MakeErrorCodeTlsProtocolError()
+
+		case 13:
+
+			variant = MakeErrorCodeTlsCertificateError()
+
+		case 14:
+			var option2 witTypes.Option[uint8]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option2 = witTypes.None[uint8]()
+			case 1:
+
+				option2 = witTypes.Some[uint8](uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 17)))))
+			default:
+				panic("unreachable")
+			}
+			var option4 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))) {
+			case 0:
+
+				option4 = witTypes.None[string]()
+			case 1:
+				value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 3*4))))
+
+				option4 = witTypes.Some[string](value3)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeTlsAlertReceived(TlsAlertReceivedPayload{option2, option4})
+
+		case 15:
+
+			variant = MakeErrorCodeHttpRequestDenied()
+
+		case 16:
+
+			variant = MakeErrorCodeHttpRequestLengthRequired()
+
+		case 17:
+			var option5 witTypes.Option[uint64]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option5 = witTypes.None[uint64]()
+			case 1:
+
+				option5 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(src), 24))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpRequestBodySize(option5)
+
+		case 18:
+
+			variant = MakeErrorCodeHttpRequestMethodInvalid()
+
+		case 19:
+
+			variant = MakeErrorCodeHttpRequestUriInvalid()
+
+		case 20:
+
+			variant = MakeErrorCodeHttpRequestUriTooLong()
+
+		case 21:
+			var option6 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option6 = witTypes.None[uint32]()
+			case 1:
+
+				option6 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), 20))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpRequestHeaderSectionSize(option6)
+
+		case 22:
+			var option10 witTypes.Option[FieldSizePayload]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option10 = witTypes.None[FieldSizePayload]()
+			case 1:
+				var option8 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))) {
+				case 0:
+
+					option8 = witTypes.None[string]()
+				case 1:
+					value7 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 3*4))))
+
+					option8 = witTypes.Some[string](value7)
+				default:
+					panic("unreachable")
+				}
+				var option9 witTypes.Option[uint32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 4*4)))) {
+				case 0:
+
+					option9 = witTypes.None[uint32]()
+				case 1:
+
+					option9 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), (20 + 4*4)))))
+				default:
+					panic("unreachable")
+				}
+
+				option10 = witTypes.Some[FieldSizePayload](FieldSizePayload{option8, option9})
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpRequestHeaderSize(option10)
+
+		case 23:
+			var option11 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option11 = witTypes.None[uint32]()
+			case 1:
+
+				option11 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), 20))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpRequestTrailerSectionSize(option11)
+
+		case 24:
+			var option13 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option13 = witTypes.None[string]()
+			case 1:
+				value12 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4))))
+
+				option13 = witTypes.Some[string](value12)
+			default:
+				panic("unreachable")
+			}
+			var option14 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 3*4)))) {
+			case 0:
+
+				option14 = witTypes.None[uint32]()
+			case 1:
+
+				option14 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), (20 + 3*4)))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpRequestTrailerSize(FieldSizePayload{option13, option14})
+
+		case 25:
+
+			variant = MakeErrorCodeHttpResponseIncomplete()
+
+		case 26:
+			var option15 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option15 = witTypes.None[uint32]()
+			case 1:
+
+				option15 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), 20))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpResponseHeaderSectionSize(option15)
+
+		case 27:
+			var option17 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option17 = witTypes.None[string]()
+			case 1:
+				value16 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4))))
+
+				option17 = witTypes.Some[string](value16)
+			default:
+				panic("unreachable")
+			}
+			var option18 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 3*4)))) {
+			case 0:
+
+				option18 = witTypes.None[uint32]()
+			case 1:
+
+				option18 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), (20 + 3*4)))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpResponseHeaderSize(FieldSizePayload{option17, option18})
+
+		case 28:
+			var option19 witTypes.Option[uint64]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option19 = witTypes.None[uint64]()
+			case 1:
+
+				option19 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(src), 24))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpResponseBodySize(option19)
+
+		case 29:
+			var option20 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option20 = witTypes.None[uint32]()
+			case 1:
+
+				option20 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), 20))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpResponseTrailerSectionSize(option20)
+
+		case 30:
+			var option22 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option22 = witTypes.None[string]()
+			case 1:
+				value21 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4))))
+
+				option22 = witTypes.Some[string](value21)
+			default:
+				panic("unreachable")
+			}
+			var option23 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 3*4)))) {
+			case 0:
+
+				option23 = witTypes.None[uint32]()
+			case 1:
+
+				option23 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), (20 + 3*4)))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpResponseTrailerSize(FieldSizePayload{option22, option23})
+
+		case 31:
+			var option25 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option25 = witTypes.None[string]()
+			case 1:
+				value24 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4))))
+
+				option25 = witTypes.Some[string](value24)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpResponseTransferCoding(option25)
+
+		case 32:
+			var option27 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option27 = witTypes.None[string]()
+			case 1:
+				value26 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4))))
+
+				option27 = witTypes.Some[string](value26)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpResponseContentCoding(option27)
+
+		case 33:
+
+			variant = MakeErrorCodeHttpResponseTimeout()
+
+		case 34:
+
+			variant = MakeErrorCodeHttpUpgradeFailed()
+
+		case 35:
+
+			variant = MakeErrorCodeHttpProtocolError()
+
+		case 36:
+
+			variant = MakeErrorCodeLoopDetected()
+
+		case 37:
+
+			variant = MakeErrorCodeConfigurationError()
+
+		case 38:
+			var option29 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option29 = witTypes.None[string]()
+			case 1:
+				value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4))))
+
+				option29 = witTypes.Some[string](value28)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeInternalError(option29)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Option[*Fields], ErrorCode](variant)
+	default:
+		panic("unreachable")
+	}
+
+	return result
+}
+
+func wasm_future_lower_result_option_fields_error_code(
+	pinner *runtime.Pinner,
+	value witTypes.Result[witTypes.Option[*Fields], ErrorCode],
+	dst unsafe.Pointer,
+) func() {
+	lifters := make([]func(), 0, 1)
+
+	switch value.Tag() {
+	case witTypes.ResultOk:
+		payload := value.Ok()
+		*(*int8)(unsafe.Add(unsafe.Pointer(dst), 0)) = int8(int32(0))
+
+		switch payload.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := payload.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(1))
+			resource := payload
+			handle := resource.TakeHandle()
+			lifters = append(lifters, func() {
+				resource.SetHandle(handle)
+			})
+			*(*int32)(unsafe.Add(unsafe.Pointer(dst), 12)) = handle
+
+		default:
+			panic("unreachable")
+		}
+
+	case witTypes.ResultErr:
+		payload := value.Err()
+		*(*int8)(unsafe.Add(unsafe.Pointer(dst), 0)) = int8(int32(1))
+
+		switch payload.Tag() {
+		case ErrorCodeDnsTimeout:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(0))
+
+		case ErrorCodeDnsError:
+			payload := payload.DnsError()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(1))
+
+			switch (payload).Rcode.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Rcode.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				utf8 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = uint32(uintptr(uintptr(utf8)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).InfoCode.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).InfoCode.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(dst), (18 + 3*4))) = int16(int32(payload))
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeDestinationNotFound:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(2))
+
+		case ErrorCodeDestinationUnavailable:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(3))
+
+		case ErrorCodeDestinationIpProhibited:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(4))
+
+		case ErrorCodeDestinationIpUnroutable:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(5))
+
+		case ErrorCodeConnectionRefused:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(6))
+
+		case ErrorCodeConnectionTerminated:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(7))
+
+		case ErrorCodeConnectionTimeout:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(8))
+
+		case ErrorCodeConnectionReadTimeout:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(9))
+
+		case ErrorCodeConnectionWriteTimeout:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(10))
+
+		case ErrorCodeConnectionLimitReached:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(11))
+
+		case ErrorCodeTlsProtocolError:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(12))
+
+		case ErrorCodeTlsCertificateError:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(13))
+
+		case ErrorCodeTlsAlertReceived:
+			payload := payload.TlsAlertReceived()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(14))
+
+			switch (payload).AlertId.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AlertId.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 17)) = int8(int32(payload))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).AlertMessage.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AlertMessage.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = int8(int32(1))
+				utf830 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf830)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uintptr(uintptr(utf830)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpRequestDenied:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(15))
+
+		case ErrorCodeHttpRequestLengthRequired:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(16))
+
+		case ErrorCodeHttpRequestBodySize:
+			payload := payload.HttpRequestBodySize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(17))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(dst), 24)) = int64(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpRequestMethodInvalid:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(18))
+
+		case ErrorCodeHttpRequestUriInvalid:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(19))
+
+		case ErrorCodeHttpRequestUriTooLong:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(20))
+
+		case ErrorCodeHttpRequestHeaderSectionSize:
+			payload := payload.HttpRequestHeaderSectionSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(21))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(dst), 20)) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpRequestHeaderSize:
+			payload := payload.HttpRequestHeaderSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(22))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+
+				switch (payload).FieldName.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).FieldName.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = int8(int32(1))
+					utf831 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf831)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uintptr(uintptr(utf831)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).FieldSize.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 4*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).FieldSize.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 4*4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(dst), (20 + 4*4))) = int32(payload)
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpRequestTrailerSectionSize:
+			payload := payload.HttpRequestTrailerSectionSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(23))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(dst), 20)) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpRequestTrailerSize:
+			payload := payload.HttpRequestTrailerSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(24))
+
+			switch (payload).FieldName.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).FieldName.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				utf832 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf832)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = uint32(uintptr(uintptr(utf832)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).FieldSize.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).FieldSize.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(dst), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseIncomplete:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(25))
+
+		case ErrorCodeHttpResponseHeaderSectionSize:
+			payload := payload.HttpResponseHeaderSectionSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(26))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(dst), 20)) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseHeaderSize:
+			payload := payload.HttpResponseHeaderSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(27))
+
+			switch (payload).FieldName.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).FieldName.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				utf833 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf833)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = uint32(uintptr(uintptr(utf833)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).FieldSize.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).FieldSize.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(dst), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseBodySize:
+			payload := payload.HttpResponseBodySize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(28))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(dst), 24)) = int64(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseTrailerSectionSize:
+			payload := payload.HttpResponseTrailerSectionSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(29))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(dst), 20)) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseTrailerSize:
+			payload := payload.HttpResponseTrailerSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(30))
+
+			switch (payload).FieldName.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).FieldName.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				utf834 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf834)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = uint32(uintptr(uintptr(utf834)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).FieldSize.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).FieldSize.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(dst), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseTransferCoding:
+			payload := payload.HttpResponseTransferCoding()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(31))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				utf835 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf835)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = uint32(uintptr(uintptr(utf835)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseContentCoding:
+			payload := payload.HttpResponseContentCoding()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(32))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				utf836 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf836)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = uint32(uintptr(uintptr(utf836)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseTimeout:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(33))
+
+		case ErrorCodeHttpUpgradeFailed:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(34))
+
+		case ErrorCodeHttpProtocolError:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(35))
+
+		case ErrorCodeLoopDetected:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(36))
+
+		case ErrorCodeConfigurationError:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(37))
+
+		case ErrorCodeInternalError:
+			payload := payload.InternalError()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(38))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				utf837 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf837)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = uint32(uintptr(uintptr(utf837)))
+
+			default:
+				panic("unreachable")
+			}
+
+		default:
+			panic("unreachable")
+		}
+
+	default:
+		panic("unreachable")
+	}
+
+	return func() {
+		for _, lifter := range lifters {
+			lifter()
+		}
+	}
+}
+
+var wasm_future_vtable_result_option_fields_error_code = witTypes.FutureVtable[witTypes.Result[witTypes.Option[*Fields], ErrorCode]]{
+	(24 + 4*4),
+	8,
+	wasm_future_read_result_option_fields_error_code,
+	wasm_future_write_result_option_fields_error_code,
+	nil,
+	nil,
+	wasm_future_drop_readable_result_option_fields_error_code,
+	wasm_future_drop_writable_result_option_fields_error_code,
+	wasm_future_lift_result_option_fields_error_code,
+	wasm_future_lower_result_option_fields_error_code,
+}
+
+func MakeFutureResultOptionFieldsErrorCode() (*witTypes.FutureWriter[witTypes.Result[witTypes.Option[*Fields], ErrorCode]], *witTypes.FutureReader[witTypes.Result[witTypes.Option[*Fields], ErrorCode]]) {
+	pair := wasm_future_new_result_option_fields_error_code()
+	return witTypes.MakeFutureWriter[witTypes.Result[witTypes.Option[*Fields], ErrorCode]](&wasm_future_vtable_result_option_fields_error_code, int32(pair>>32)),
+		witTypes.MakeFutureReader[witTypes.Result[witTypes.Option[*Fields], ErrorCode]](&wasm_future_vtable_result_option_fields_error_code, int32(pair&0xFFFFFFFF))
+}
+
+func LiftFutureResultOptionFieldsErrorCode(handle int32) *witTypes.FutureReader[witTypes.Result[witTypes.Option[*Fields], ErrorCode]] {
+	return witTypes.MakeFutureReader[witTypes.Result[witTypes.Option[*Fields], ErrorCode]](&wasm_future_vtable_result_option_fields_error_code, handle)
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [future-new-2][static]request.new
+func wasm_future_new_result_unit_error_code() uint64
+
+//go:wasmimport wasi:http/types@0.3.0 [async-lower][future-read-2][static]request.new
+func wasm_future_read_result_unit_error_code(handle int32, item unsafe.Pointer) uint32
+
+//go:wasmimport wasi:http/types@0.3.0 [async-lower][future-write-2][static]request.new
+func wasm_future_write_result_unit_error_code(handle int32, item unsafe.Pointer) uint32
+
+//go:wasmimport wasi:http/types@0.3.0 [future-drop-readable-2][static]request.new
+func wasm_future_drop_readable_result_unit_error_code(handle int32)
+
+//go:wasmimport wasi:http/types@0.3.0 [future-drop-writable-2][static]request.new
+func wasm_future_drop_writable_result_unit_error_code(handle int32)
+
+func wasm_future_lift_result_unit_error_code(src unsafe.Pointer) witTypes.Result[witTypes.Unit, ErrorCode] {
+	var result witTypes.Result[witTypes.Unit, ErrorCode]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, ErrorCode](witTypes.Unit{})
+	case 1:
+		var variant ErrorCode
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 8))) {
+		case 0:
+
+			variant = MakeErrorCodeDnsTimeout()
+
+		case 1:
+			var option witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option = witTypes.None[string]()
+			case 1:
+				value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4))))
+
+				option = witTypes.Some[string](value)
+			default:
+				panic("unreachable")
+			}
+			var option0 witTypes.Option[uint16]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 3*4)))) {
+			case 0:
+
+				option0 = witTypes.None[uint16]()
+			case 1:
+
+				option0 = witTypes.Some[uint16](uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (18 + 3*4))))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeDnsError(DnsErrorPayload{option, option0})
+
+		case 2:
+
+			variant = MakeErrorCodeDestinationNotFound()
+
+		case 3:
+
+			variant = MakeErrorCodeDestinationUnavailable()
+
+		case 4:
+
+			variant = MakeErrorCodeDestinationIpProhibited()
+
+		case 5:
+
+			variant = MakeErrorCodeDestinationIpUnroutable()
+
+		case 6:
+
+			variant = MakeErrorCodeConnectionRefused()
+
+		case 7:
+
+			variant = MakeErrorCodeConnectionTerminated()
+
+		case 8:
+
+			variant = MakeErrorCodeConnectionTimeout()
+
+		case 9:
+
+			variant = MakeErrorCodeConnectionReadTimeout()
+
+		case 10:
+
+			variant = MakeErrorCodeConnectionWriteTimeout()
+
+		case 11:
+
+			variant = MakeErrorCodeConnectionLimitReached()
+
+		case 12:
+
+			variant = MakeErrorCodeTlsProtocolError()
+
+		case 13:
+
+			variant = MakeErrorCodeTlsCertificateError()
+
+		case 14:
+			var option1 witTypes.Option[uint8]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option1 = witTypes.None[uint8]()
+			case 1:
+
+				option1 = witTypes.Some[uint8](uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 17)))))
+			default:
+				panic("unreachable")
+			}
+			var option3 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))) {
+			case 0:
+
+				option3 = witTypes.None[string]()
+			case 1:
+				value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 3*4))))
+
+				option3 = witTypes.Some[string](value2)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeTlsAlertReceived(TlsAlertReceivedPayload{option1, option3})
+
+		case 15:
+
+			variant = MakeErrorCodeHttpRequestDenied()
+
+		case 16:
+
+			variant = MakeErrorCodeHttpRequestLengthRequired()
+
+		case 17:
+			var option4 witTypes.Option[uint64]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option4 = witTypes.None[uint64]()
+			case 1:
+
+				option4 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(src), 24))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpRequestBodySize(option4)
+
+		case 18:
+
+			variant = MakeErrorCodeHttpRequestMethodInvalid()
+
+		case 19:
+
+			variant = MakeErrorCodeHttpRequestUriInvalid()
+
+		case 20:
+
+			variant = MakeErrorCodeHttpRequestUriTooLong()
+
+		case 21:
+			var option5 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option5 = witTypes.None[uint32]()
+			case 1:
+
+				option5 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), 20))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpRequestHeaderSectionSize(option5)
+
+		case 22:
+			var option9 witTypes.Option[FieldSizePayload]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option9 = witTypes.None[FieldSizePayload]()
+			case 1:
+				var option7 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))) {
+				case 0:
+
+					option7 = witTypes.None[string]()
+				case 1:
+					value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 3*4))))
+
+					option7 = witTypes.Some[string](value6)
+				default:
+					panic("unreachable")
+				}
+				var option8 witTypes.Option[uint32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 4*4)))) {
+				case 0:
+
+					option8 = witTypes.None[uint32]()
+				case 1:
+
+					option8 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), (20 + 4*4)))))
+				default:
+					panic("unreachable")
+				}
+
+				option9 = witTypes.Some[FieldSizePayload](FieldSizePayload{option7, option8})
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpRequestHeaderSize(option9)
+
+		case 23:
+			var option10 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option10 = witTypes.None[uint32]()
+			case 1:
+
+				option10 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), 20))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpRequestTrailerSectionSize(option10)
+
+		case 24:
+			var option12 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option12 = witTypes.None[string]()
+			case 1:
+				value11 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4))))
+
+				option12 = witTypes.Some[string](value11)
+			default:
+				panic("unreachable")
+			}
+			var option13 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 3*4)))) {
+			case 0:
+
+				option13 = witTypes.None[uint32]()
+			case 1:
+
+				option13 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), (20 + 3*4)))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpRequestTrailerSize(FieldSizePayload{option12, option13})
+
+		case 25:
+
+			variant = MakeErrorCodeHttpResponseIncomplete()
+
+		case 26:
+			var option14 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option14 = witTypes.None[uint32]()
+			case 1:
+
+				option14 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), 20))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpResponseHeaderSectionSize(option14)
+
+		case 27:
+			var option16 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option16 = witTypes.None[string]()
+			case 1:
+				value15 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4))))
+
+				option16 = witTypes.Some[string](value15)
+			default:
+				panic("unreachable")
+			}
+			var option17 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 3*4)))) {
+			case 0:
+
+				option17 = witTypes.None[uint32]()
+			case 1:
+
+				option17 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), (20 + 3*4)))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpResponseHeaderSize(FieldSizePayload{option16, option17})
+
+		case 28:
+			var option18 witTypes.Option[uint64]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option18 = witTypes.None[uint64]()
+			case 1:
+
+				option18 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(src), 24))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpResponseBodySize(option18)
+
+		case 29:
+			var option19 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option19 = witTypes.None[uint32]()
+			case 1:
+
+				option19 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), 20))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpResponseTrailerSectionSize(option19)
+
+		case 30:
+			var option21 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option21 = witTypes.None[string]()
+			case 1:
+				value20 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4))))
+
+				option21 = witTypes.Some[string](value20)
+			default:
+				panic("unreachable")
+			}
+			var option22 witTypes.Option[uint32]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 3*4)))) {
+			case 0:
+
+				option22 = witTypes.None[uint32]()
+			case 1:
+
+				option22 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(src), (20 + 3*4)))))
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpResponseTrailerSize(FieldSizePayload{option21, option22})
+
+		case 31:
+			var option24 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option24 = witTypes.None[string]()
+			case 1:
+				value23 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4))))
+
+				option24 = witTypes.Some[string](value23)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpResponseTransferCoding(option24)
+
+		case 32:
+			var option26 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option26 = witTypes.None[string]()
+			case 1:
+				value25 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4))))
+
+				option26 = witTypes.Some[string](value25)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeHttpResponseContentCoding(option26)
+
+		case 33:
+
+			variant = MakeErrorCodeHttpResponseTimeout()
+
+		case 34:
+
+			variant = MakeErrorCodeHttpUpgradeFailed()
+
+		case 35:
+
+			variant = MakeErrorCodeHttpProtocolError()
+
+		case 36:
+
+			variant = MakeErrorCodeLoopDetected()
+
+		case 37:
+
+			variant = MakeErrorCodeConfigurationError()
+
+		case 38:
+			var option28 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(src), 16))) {
+			case 0:
+
+				option28 = witTypes.None[string]()
+			case 1:
+				value27 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(src), (16 + 2*4))))
+
+				option28 = witTypes.Some[string](value27)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeErrorCodeInternalError(option28)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Unit, ErrorCode](variant)
+	default:
+		panic("unreachable")
+	}
+
+	return result
+}
+
+func wasm_future_lower_result_unit_error_code(
+	pinner *runtime.Pinner,
+	value witTypes.Result[witTypes.Unit, ErrorCode],
+	dst unsafe.Pointer,
+) func() {
+
+	switch value.Tag() {
+	case witTypes.ResultOk:
+
+		*(*int8)(unsafe.Add(unsafe.Pointer(dst), 0)) = int8(int32(0))
+
+	case witTypes.ResultErr:
+		payload := value.Err()
+		*(*int8)(unsafe.Add(unsafe.Pointer(dst), 0)) = int8(int32(1))
+
+		switch payload.Tag() {
+		case ErrorCodeDnsTimeout:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(0))
+
+		case ErrorCodeDnsError:
+			payload := payload.DnsError()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(1))
+
+			switch (payload).Rcode.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Rcode.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				utf8 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = uint32(uintptr(uintptr(utf8)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).InfoCode.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).InfoCode.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(1))
+				*(*int16)(unsafe.Add(unsafe.Pointer(dst), (18 + 3*4))) = int16(int32(payload))
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeDestinationNotFound:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(2))
+
+		case ErrorCodeDestinationUnavailable:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(3))
+
+		case ErrorCodeDestinationIpProhibited:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(4))
+
+		case ErrorCodeDestinationIpUnroutable:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(5))
+
+		case ErrorCodeConnectionRefused:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(6))
+
+		case ErrorCodeConnectionTerminated:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(7))
+
+		case ErrorCodeConnectionTimeout:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(8))
+
+		case ErrorCodeConnectionReadTimeout:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(9))
+
+		case ErrorCodeConnectionWriteTimeout:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(10))
+
+		case ErrorCodeConnectionLimitReached:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(11))
+
+		case ErrorCodeTlsProtocolError:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(12))
+
+		case ErrorCodeTlsCertificateError:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(13))
+
+		case ErrorCodeTlsAlertReceived:
+			payload := payload.TlsAlertReceived()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(14))
+
+			switch (payload).AlertId.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AlertId.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 17)) = int8(int32(payload))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).AlertMessage.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AlertMessage.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = int8(int32(1))
+				utf829 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf829)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uintptr(uintptr(utf829)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpRequestDenied:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(15))
+
+		case ErrorCodeHttpRequestLengthRequired:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(16))
+
+		case ErrorCodeHttpRequestBodySize:
+			payload := payload.HttpRequestBodySize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(17))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(dst), 24)) = int64(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpRequestMethodInvalid:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(18))
+
+		case ErrorCodeHttpRequestUriInvalid:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(19))
+
+		case ErrorCodeHttpRequestUriTooLong:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(20))
+
+		case ErrorCodeHttpRequestHeaderSectionSize:
+			payload := payload.HttpRequestHeaderSectionSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(21))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(dst), 20)) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpRequestHeaderSize:
+			payload := payload.HttpRequestHeaderSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(22))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+
+				switch (payload).FieldName.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).FieldName.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = int8(int32(1))
+					utf830 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf830)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uintptr(uintptr(utf830)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).FieldSize.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 4*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).FieldSize.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 4*4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(dst), (20 + 4*4))) = int32(payload)
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpRequestTrailerSectionSize:
+			payload := payload.HttpRequestTrailerSectionSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(23))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(dst), 20)) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpRequestTrailerSize:
+			payload := payload.HttpRequestTrailerSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(24))
+
+			switch (payload).FieldName.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).FieldName.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				utf831 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf831)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = uint32(uintptr(uintptr(utf831)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).FieldSize.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).FieldSize.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(dst), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseIncomplete:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(25))
+
+		case ErrorCodeHttpResponseHeaderSectionSize:
+			payload := payload.HttpResponseHeaderSectionSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(26))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(dst), 20)) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseHeaderSize:
+			payload := payload.HttpResponseHeaderSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(27))
+
+			switch (payload).FieldName.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).FieldName.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				utf832 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf832)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = uint32(uintptr(uintptr(utf832)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).FieldSize.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).FieldSize.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(dst), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseBodySize:
+			payload := payload.HttpResponseBodySize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(28))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(dst), 24)) = int64(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseTrailerSectionSize:
+			payload := payload.HttpResponseTrailerSectionSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(29))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(dst), 20)) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseTrailerSize:
+			payload := payload.HttpResponseTrailerSize()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(30))
+
+			switch (payload).FieldName.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).FieldName.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				utf833 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf833)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = uint32(uintptr(uintptr(utf833)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).FieldSize.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).FieldSize.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(dst), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseTransferCoding:
+			payload := payload.HttpResponseTransferCoding()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(31))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				utf834 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf834)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = uint32(uintptr(uintptr(utf834)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseContentCoding:
+			payload := payload.HttpResponseContentCoding()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(32))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				utf835 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf835)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = uint32(uintptr(uintptr(utf835)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case ErrorCodeHttpResponseTimeout:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(33))
+
+		case ErrorCodeHttpUpgradeFailed:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(34))
+
+		case ErrorCodeHttpProtocolError:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(35))
+
+		case ErrorCodeLoopDetected:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(36))
+
+		case ErrorCodeConfigurationError:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(37))
+
+		case ErrorCodeInternalError:
+			payload := payload.InternalError()
+			*(*int8)(unsafe.Add(unsafe.Pointer(dst), 8)) = int8(int32(38))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(dst), 16)) = int8(int32(1))
+				utf836 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf836)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(dst), (16 + 1*4))) = uint32(uintptr(uintptr(utf836)))
+
+			default:
+				panic("unreachable")
+			}
+
+		default:
+			panic("unreachable")
+		}
+
+	default:
+		panic("unreachable")
+	}
+
+	return func() {}
+}
+
+var wasm_future_vtable_result_unit_error_code = witTypes.FutureVtable[witTypes.Result[witTypes.Unit, ErrorCode]]{
+	(24 + 4*4),
+	8,
+	wasm_future_read_result_unit_error_code,
+	wasm_future_write_result_unit_error_code,
+	nil,
+	nil,
+	wasm_future_drop_readable_result_unit_error_code,
+	wasm_future_drop_writable_result_unit_error_code,
+	wasm_future_lift_result_unit_error_code,
+	wasm_future_lower_result_unit_error_code,
+}
+
+func MakeFutureResultUnitErrorCode() (*witTypes.FutureWriter[witTypes.Result[witTypes.Unit, ErrorCode]], *witTypes.FutureReader[witTypes.Result[witTypes.Unit, ErrorCode]]) {
+	pair := wasm_future_new_result_unit_error_code()
+	return witTypes.MakeFutureWriter[witTypes.Result[witTypes.Unit, ErrorCode]](&wasm_future_vtable_result_unit_error_code, int32(pair>>32)),
+		witTypes.MakeFutureReader[witTypes.Result[witTypes.Unit, ErrorCode]](&wasm_future_vtable_result_unit_error_code, int32(pair&0xFFFFFFFF))
+}
+
+func LiftFutureResultUnitErrorCode(handle int32) *witTypes.FutureReader[witTypes.Result[witTypes.Unit, ErrorCode]] {
+	return witTypes.MakeFutureReader[witTypes.Result[witTypes.Unit, ErrorCode]](&wasm_future_vtable_result_unit_error_code, handle)
+}
+
+type Duration = uint64
+
+const (
+	MethodGet     uint8 = 0
+	MethodHead    uint8 = 1
+	MethodPost    uint8 = 2
+	MethodPut     uint8 = 3
+	MethodDelete  uint8 = 4
+	MethodConnect uint8 = 5
+	MethodOptions uint8 = 6
+	MethodTrace   uint8 = 7
+	MethodPatch   uint8 = 8
+	MethodOther   uint8 = 9
+)
+
+// This type corresponds to HTTP standard Methods.
+type Method struct {
+	tag   uint8
+	value any
+}
+
+func (self Method) Tag() uint8 {
+	return self.tag
+}
+
+func (self Method) Other() string {
+	if self.tag != MethodOther {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+
+func MakeMethodGet() Method {
+	return Method{MethodGet, nil}
+}
+func MakeMethodHead() Method {
+	return Method{MethodHead, nil}
+}
+func MakeMethodPost() Method {
+	return Method{MethodPost, nil}
+}
+func MakeMethodPut() Method {
+	return Method{MethodPut, nil}
+}
+func MakeMethodDelete() Method {
+	return Method{MethodDelete, nil}
+}
+func MakeMethodConnect() Method {
+	return Method{MethodConnect, nil}
+}
+func MakeMethodOptions() Method {
+	return Method{MethodOptions, nil}
+}
+func MakeMethodTrace() Method {
+	return Method{MethodTrace, nil}
+}
+func MakeMethodPatch() Method {
+	return Method{MethodPatch, nil}
+}
+func MakeMethodOther(value string) Method {
+	return Method{MethodOther, value}
+}
+
+const (
+	SchemeHttp  uint8 = 0
+	SchemeHttps uint8 = 1
+	SchemeOther uint8 = 2
+)
+
+// This type corresponds to HTTP standard Related Schemes.
+type Scheme struct {
+	tag   uint8
+	value any
+}
+
+func (self Scheme) Tag() uint8 {
+	return self.tag
+}
+
+func (self Scheme) Other() string {
+	if self.tag != SchemeOther {
+		panic("tag mismatch")
+	}
+	return self.value.(string)
+}
+
+func MakeSchemeHttp() Scheme {
+	return Scheme{SchemeHttp, nil}
+}
+func MakeSchemeHttps() Scheme {
+	return Scheme{SchemeHttps, nil}
+}
+func MakeSchemeOther(value string) Scheme {
+	return Scheme{SchemeOther, value}
+}
+
+// Defines the case payload type for `DNS-error` above:
+type DnsErrorPayload struct {
+	Rcode    witTypes.Option[string]
+	InfoCode witTypes.Option[uint16]
+}
+
+// Defines the case payload type for `TLS-alert-received` above:
+type TlsAlertReceivedPayload struct {
+	AlertId      witTypes.Option[uint8]
+	AlertMessage witTypes.Option[string]
+}
+
+// Defines the case payload type for `HTTP-response-{header,trailer}-size` above:
+type FieldSizePayload struct {
+	FieldName witTypes.Option[string]
+	FieldSize witTypes.Option[uint32]
+}
+
+const (
+	ErrorCodeDnsTimeout                     uint8 = 0
+	ErrorCodeDnsError                       uint8 = 1
+	ErrorCodeDestinationNotFound            uint8 = 2
+	ErrorCodeDestinationUnavailable         uint8 = 3
+	ErrorCodeDestinationIpProhibited        uint8 = 4
+	ErrorCodeDestinationIpUnroutable        uint8 = 5
+	ErrorCodeConnectionRefused              uint8 = 6
+	ErrorCodeConnectionTerminated           uint8 = 7
+	ErrorCodeConnectionTimeout              uint8 = 8
+	ErrorCodeConnectionReadTimeout          uint8 = 9
+	ErrorCodeConnectionWriteTimeout         uint8 = 10
+	ErrorCodeConnectionLimitReached         uint8 = 11
+	ErrorCodeTlsProtocolError               uint8 = 12
+	ErrorCodeTlsCertificateError            uint8 = 13
+	ErrorCodeTlsAlertReceived               uint8 = 14
+	ErrorCodeHttpRequestDenied              uint8 = 15
+	ErrorCodeHttpRequestLengthRequired      uint8 = 16
+	ErrorCodeHttpRequestBodySize            uint8 = 17
+	ErrorCodeHttpRequestMethodInvalid       uint8 = 18
+	ErrorCodeHttpRequestUriInvalid          uint8 = 19
+	ErrorCodeHttpRequestUriTooLong          uint8 = 20
+	ErrorCodeHttpRequestHeaderSectionSize   uint8 = 21
+	ErrorCodeHttpRequestHeaderSize          uint8 = 22
+	ErrorCodeHttpRequestTrailerSectionSize  uint8 = 23
+	ErrorCodeHttpRequestTrailerSize         uint8 = 24
+	ErrorCodeHttpResponseIncomplete         uint8 = 25
+	ErrorCodeHttpResponseHeaderSectionSize  uint8 = 26
+	ErrorCodeHttpResponseHeaderSize         uint8 = 27
+	ErrorCodeHttpResponseBodySize           uint8 = 28
+	ErrorCodeHttpResponseTrailerSectionSize uint8 = 29
+	ErrorCodeHttpResponseTrailerSize        uint8 = 30
+	ErrorCodeHttpResponseTransferCoding     uint8 = 31
+	ErrorCodeHttpResponseContentCoding      uint8 = 32
+	ErrorCodeHttpResponseTimeout            uint8 = 33
+	ErrorCodeHttpUpgradeFailed              uint8 = 34
+	ErrorCodeHttpProtocolError              uint8 = 35
+	ErrorCodeLoopDetected                   uint8 = 36
+	ErrorCodeConfigurationError             uint8 = 37
+	// This is a catch-all error for anything that doesn't fit cleanly into a
+	// more specific case. It also includes an optional string for an
+	// unstructured description of the error. Users should not depend on the
+	// string for diagnosing errors, as it's not required to be consistent
+	// between implementations.
+	ErrorCodeInternalError uint8 = 38
+)
+
+// These cases are inspired by the IANA HTTP Proxy Error Types:
+//
+//	<https://www.iana.org/assignments/http-proxy-status/http-proxy-status.xhtml#table-http-proxy-error-types>
+type ErrorCode struct {
+	tag   uint8
+	value any
+}
+
+func (self ErrorCode) Tag() uint8 {
+	return self.tag
+}
+
+func (self ErrorCode) DnsError() DnsErrorPayload {
+	if self.tag != ErrorCodeDnsError {
+		panic("tag mismatch")
+	}
+	return self.value.(DnsErrorPayload)
+}
+func (self ErrorCode) TlsAlertReceived() TlsAlertReceivedPayload {
+	if self.tag != ErrorCodeTlsAlertReceived {
+		panic("tag mismatch")
+	}
+	return self.value.(TlsAlertReceivedPayload)
+}
+func (self ErrorCode) HttpRequestBodySize() witTypes.Option[uint64] {
+	if self.tag != ErrorCodeHttpRequestBodySize {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[uint64])
+}
+func (self ErrorCode) HttpRequestHeaderSectionSize() witTypes.Option[uint32] {
+	if self.tag != ErrorCodeHttpRequestHeaderSectionSize {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[uint32])
+}
+func (self ErrorCode) HttpRequestHeaderSize() witTypes.Option[FieldSizePayload] {
+	if self.tag != ErrorCodeHttpRequestHeaderSize {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[FieldSizePayload])
+}
+func (self ErrorCode) HttpRequestTrailerSectionSize() witTypes.Option[uint32] {
+	if self.tag != ErrorCodeHttpRequestTrailerSectionSize {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[uint32])
+}
+func (self ErrorCode) HttpRequestTrailerSize() FieldSizePayload {
+	if self.tag != ErrorCodeHttpRequestTrailerSize {
+		panic("tag mismatch")
+	}
+	return self.value.(FieldSizePayload)
+}
+func (self ErrorCode) HttpResponseHeaderSectionSize() witTypes.Option[uint32] {
+	if self.tag != ErrorCodeHttpResponseHeaderSectionSize {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[uint32])
+}
+func (self ErrorCode) HttpResponseHeaderSize() FieldSizePayload {
+	if self.tag != ErrorCodeHttpResponseHeaderSize {
+		panic("tag mismatch")
+	}
+	return self.value.(FieldSizePayload)
+}
+func (self ErrorCode) HttpResponseBodySize() witTypes.Option[uint64] {
+	if self.tag != ErrorCodeHttpResponseBodySize {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[uint64])
+}
+func (self ErrorCode) HttpResponseTrailerSectionSize() witTypes.Option[uint32] {
+	if self.tag != ErrorCodeHttpResponseTrailerSectionSize {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[uint32])
+}
+func (self ErrorCode) HttpResponseTrailerSize() FieldSizePayload {
+	if self.tag != ErrorCodeHttpResponseTrailerSize {
+		panic("tag mismatch")
+	}
+	return self.value.(FieldSizePayload)
+}
+func (self ErrorCode) HttpResponseTransferCoding() witTypes.Option[string] {
+	if self.tag != ErrorCodeHttpResponseTransferCoding {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[string])
+}
+func (self ErrorCode) HttpResponseContentCoding() witTypes.Option[string] {
+	if self.tag != ErrorCodeHttpResponseContentCoding {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[string])
+}
+func (self ErrorCode) InternalError() witTypes.Option[string] {
+	if self.tag != ErrorCodeInternalError {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[string])
+}
+
+func MakeErrorCodeDnsTimeout() ErrorCode {
+	return ErrorCode{ErrorCodeDnsTimeout, nil}
+}
+func MakeErrorCodeDnsError(value DnsErrorPayload) ErrorCode {
+	return ErrorCode{ErrorCodeDnsError, value}
+}
+func MakeErrorCodeDestinationNotFound() ErrorCode {
+	return ErrorCode{ErrorCodeDestinationNotFound, nil}
+}
+func MakeErrorCodeDestinationUnavailable() ErrorCode {
+	return ErrorCode{ErrorCodeDestinationUnavailable, nil}
+}
+func MakeErrorCodeDestinationIpProhibited() ErrorCode {
+	return ErrorCode{ErrorCodeDestinationIpProhibited, nil}
+}
+func MakeErrorCodeDestinationIpUnroutable() ErrorCode {
+	return ErrorCode{ErrorCodeDestinationIpUnroutable, nil}
+}
+func MakeErrorCodeConnectionRefused() ErrorCode {
+	return ErrorCode{ErrorCodeConnectionRefused, nil}
+}
+func MakeErrorCodeConnectionTerminated() ErrorCode {
+	return ErrorCode{ErrorCodeConnectionTerminated, nil}
+}
+func MakeErrorCodeConnectionTimeout() ErrorCode {
+	return ErrorCode{ErrorCodeConnectionTimeout, nil}
+}
+func MakeErrorCodeConnectionReadTimeout() ErrorCode {
+	return ErrorCode{ErrorCodeConnectionReadTimeout, nil}
+}
+func MakeErrorCodeConnectionWriteTimeout() ErrorCode {
+	return ErrorCode{ErrorCodeConnectionWriteTimeout, nil}
+}
+func MakeErrorCodeConnectionLimitReached() ErrorCode {
+	return ErrorCode{ErrorCodeConnectionLimitReached, nil}
+}
+func MakeErrorCodeTlsProtocolError() ErrorCode {
+	return ErrorCode{ErrorCodeTlsProtocolError, nil}
+}
+func MakeErrorCodeTlsCertificateError() ErrorCode {
+	return ErrorCode{ErrorCodeTlsCertificateError, nil}
+}
+func MakeErrorCodeTlsAlertReceived(value TlsAlertReceivedPayload) ErrorCode {
+	return ErrorCode{ErrorCodeTlsAlertReceived, value}
+}
+func MakeErrorCodeHttpRequestDenied() ErrorCode {
+	return ErrorCode{ErrorCodeHttpRequestDenied, nil}
+}
+func MakeErrorCodeHttpRequestLengthRequired() ErrorCode {
+	return ErrorCode{ErrorCodeHttpRequestLengthRequired, nil}
+}
+func MakeErrorCodeHttpRequestBodySize(value witTypes.Option[uint64]) ErrorCode {
+	return ErrorCode{ErrorCodeHttpRequestBodySize, value}
+}
+func MakeErrorCodeHttpRequestMethodInvalid() ErrorCode {
+	return ErrorCode{ErrorCodeHttpRequestMethodInvalid, nil}
+}
+func MakeErrorCodeHttpRequestUriInvalid() ErrorCode {
+	return ErrorCode{ErrorCodeHttpRequestUriInvalid, nil}
+}
+func MakeErrorCodeHttpRequestUriTooLong() ErrorCode {
+	return ErrorCode{ErrorCodeHttpRequestUriTooLong, nil}
+}
+func MakeErrorCodeHttpRequestHeaderSectionSize(value witTypes.Option[uint32]) ErrorCode {
+	return ErrorCode{ErrorCodeHttpRequestHeaderSectionSize, value}
+}
+func MakeErrorCodeHttpRequestHeaderSize(value witTypes.Option[FieldSizePayload]) ErrorCode {
+	return ErrorCode{ErrorCodeHttpRequestHeaderSize, value}
+}
+func MakeErrorCodeHttpRequestTrailerSectionSize(value witTypes.Option[uint32]) ErrorCode {
+	return ErrorCode{ErrorCodeHttpRequestTrailerSectionSize, value}
+}
+func MakeErrorCodeHttpRequestTrailerSize(value FieldSizePayload) ErrorCode {
+	return ErrorCode{ErrorCodeHttpRequestTrailerSize, value}
+}
+func MakeErrorCodeHttpResponseIncomplete() ErrorCode {
+	return ErrorCode{ErrorCodeHttpResponseIncomplete, nil}
+}
+func MakeErrorCodeHttpResponseHeaderSectionSize(value witTypes.Option[uint32]) ErrorCode {
+	return ErrorCode{ErrorCodeHttpResponseHeaderSectionSize, value}
+}
+func MakeErrorCodeHttpResponseHeaderSize(value FieldSizePayload) ErrorCode {
+	return ErrorCode{ErrorCodeHttpResponseHeaderSize, value}
+}
+func MakeErrorCodeHttpResponseBodySize(value witTypes.Option[uint64]) ErrorCode {
+	return ErrorCode{ErrorCodeHttpResponseBodySize, value}
+}
+func MakeErrorCodeHttpResponseTrailerSectionSize(value witTypes.Option[uint32]) ErrorCode {
+	return ErrorCode{ErrorCodeHttpResponseTrailerSectionSize, value}
+}
+func MakeErrorCodeHttpResponseTrailerSize(value FieldSizePayload) ErrorCode {
+	return ErrorCode{ErrorCodeHttpResponseTrailerSize, value}
+}
+func MakeErrorCodeHttpResponseTransferCoding(value witTypes.Option[string]) ErrorCode {
+	return ErrorCode{ErrorCodeHttpResponseTransferCoding, value}
+}
+func MakeErrorCodeHttpResponseContentCoding(value witTypes.Option[string]) ErrorCode {
+	return ErrorCode{ErrorCodeHttpResponseContentCoding, value}
+}
+func MakeErrorCodeHttpResponseTimeout() ErrorCode {
+	return ErrorCode{ErrorCodeHttpResponseTimeout, nil}
+}
+func MakeErrorCodeHttpUpgradeFailed() ErrorCode {
+	return ErrorCode{ErrorCodeHttpUpgradeFailed, nil}
+}
+func MakeErrorCodeHttpProtocolError() ErrorCode {
+	return ErrorCode{ErrorCodeHttpProtocolError, nil}
+}
+func MakeErrorCodeLoopDetected() ErrorCode {
+	return ErrorCode{ErrorCodeLoopDetected, nil}
+}
+func MakeErrorCodeConfigurationError() ErrorCode {
+	return ErrorCode{ErrorCodeConfigurationError, nil}
+}
+func MakeErrorCodeInternalError(value witTypes.Option[string]) ErrorCode {
+	return ErrorCode{ErrorCodeInternalError, value}
+}
+
+const (
+	// This error indicates that a `field-name` or `field-value` was
+	// syntactically invalid when used with an operation that sets headers in a
+	// `fields`.
+	HeaderErrorInvalidSyntax uint8 = 0
+	// This error indicates that a forbidden `field-name` was used when trying
+	// to set a header in a `fields`.
+	HeaderErrorForbidden uint8 = 1
+	// This error indicates that the operation on the `fields` was not
+	// permitted because the fields are immutable.
+	HeaderErrorImmutable uint8 = 2
+	// This error indicates that the operation would exceed an
+	// implementation-defined limit on field sizes. This may apply to
+	// an individual `field-value`, a single `field-name` plus all its
+	// values, or the total aggregate size of all fields.
+	HeaderErrorSizeExceeded uint8 = 3
+	// This is a catch-all error for anything that doesn't fit cleanly into a
+	// more specific case. Implementations can use this to extend the error
+	// type without breaking existing code. It also includes an optional
+	// string for an unstructured description of the error. Users should not
+	// depend on the string for diagnosing errors, as it's not required to be
+	// consistent between implementations.
+	HeaderErrorOther uint8 = 4
+)
+
+// This type enumerates the different kinds of errors that may occur when
+// setting or appending to a `fields` resource.
+type HeaderError struct {
+	tag   uint8
+	value any
+}
+
+func (self HeaderError) Tag() uint8 {
+	return self.tag
+}
+
+func (self HeaderError) Other() witTypes.Option[string] {
+	if self.tag != HeaderErrorOther {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[string])
+}
+
+func MakeHeaderErrorInvalidSyntax() HeaderError {
+	return HeaderError{HeaderErrorInvalidSyntax, nil}
+}
+func MakeHeaderErrorForbidden() HeaderError {
+	return HeaderError{HeaderErrorForbidden, nil}
+}
+func MakeHeaderErrorImmutable() HeaderError {
+	return HeaderError{HeaderErrorImmutable, nil}
+}
+func MakeHeaderErrorSizeExceeded() HeaderError {
+	return HeaderError{HeaderErrorSizeExceeded, nil}
+}
+func MakeHeaderErrorOther(value witTypes.Option[string]) HeaderError {
+	return HeaderError{HeaderErrorOther, value}
+}
+
+const (
+	// Indicates the specified field is not supported by this implementation.
+	RequestOptionsErrorNotSupported uint8 = 0
+	// Indicates that the operation on the `request-options` was not permitted
+	// because it is immutable.
+	RequestOptionsErrorImmutable uint8 = 1
+	// This is a catch-all error for anything that doesn't fit cleanly into a
+	// more specific case. Implementations can use this to extend the error
+	// type without breaking existing code. It also includes an optional
+	// string for an unstructured description of the error. Users should not
+	// depend on the string for diagnosing errors, as it's not required to be
+	// consistent between implementations.
+	RequestOptionsErrorOther uint8 = 2
+)
+
+// This type enumerates the different kinds of errors that may occur when
+// setting fields of a `request-options` resource.
+type RequestOptionsError struct {
+	tag   uint8
+	value any
+}
+
+func (self RequestOptionsError) Tag() uint8 {
+	return self.tag
+}
+
+func (self RequestOptionsError) Other() witTypes.Option[string] {
+	if self.tag != RequestOptionsErrorOther {
+		panic("tag mismatch")
+	}
+	return self.value.(witTypes.Option[string])
+}
+
+func MakeRequestOptionsErrorNotSupported() RequestOptionsError {
+	return RequestOptionsError{RequestOptionsErrorNotSupported, nil}
+}
+func MakeRequestOptionsErrorImmutable() RequestOptionsError {
+	return RequestOptionsError{RequestOptionsErrorImmutable, nil}
+}
+func MakeRequestOptionsErrorOther(value witTypes.Option[string]) RequestOptionsError {
+	return RequestOptionsError{RequestOptionsErrorOther, value}
+}
+
+// Field names are always strings.
+//
+// Field names should always be treated as case insensitive by the `fields`
+// resource for the purposes of equality checking.
+type FieldName = string
+
+// Field values should always be ASCII strings. However, in
+// reality, HTTP implementations often have to interpret malformed values,
+// so they are provided as a list of bytes.
+type FieldValue = []uint8
+
+//go:wasmimport wasi:http/types@0.3.0 [resource-drop]fields
+func resourceDropFields(handle int32)
+
+// This following block defines the `fields` resource which corresponds to
+// HTTP standard Fields. Fields are a common representation used for both
+// Headers and Trailers.
+//
+// A `fields` may be mutable or immutable. A `fields` created using the
+// constructor, `from-list`, or `clone` will be mutable, but a `fields`
+// resource given by other means (including, but not limited to,
+// `request.headers`) might be be immutable. In an immutable fields, the
+// `set`, `append`, and `delete` operations will fail with
+// `header-error.immutable`.
+//
+// A `fields` resource should store `field-name`s and `field-value`s in their
+// original casing used to construct or mutate the `fields` resource. The `fields`
+// resource should use that original casing when serializing the fields for
+// transport or when returning them from a method.
+//
+// Implementations may impose limits on individual field values and on total
+// aggregate field section size. Operations that would exceed these limits
+// fail with `header-error.size-exceeded`
+type Fields struct {
+	handle *witRuntime.Handle
+}
+
+func (self *Fields) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *Fields) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *Fields) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *Fields) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropFields(handle)
+	}
+}
+
+func FieldsFromOwnHandle(handleValue int32) *Fields {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &Fields{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropFields(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func FieldsFromBorrowHandle(handleValue int32) *Fields {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &Fields{handle}
+}
+
+// Headers is an alias for Fields.
+type Headers = Fields
+
+// Trailers is an alias for Fields.
+type Trailers = Fields
+
+//go:wasmimport wasi:http/types@0.3.0 [resource-drop]request
+func resourceDropRequest(handle int32)
+
+// Represents an HTTP Request.
+type Request struct {
+	handle *witRuntime.Handle
+}
+
+func (self *Request) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *Request) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *Request) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *Request) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropRequest(handle)
+	}
+}
+
+func RequestFromOwnHandle(handleValue int32) *Request {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &Request{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropRequest(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func RequestFromBorrowHandle(handleValue int32) *Request {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &Request{handle}
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [resource-drop]request-options
+func resourceDropRequestOptions(handle int32)
+
+// Parameters for making an HTTP Request. Each of these parameters is
+// currently an optional timeout applicable to the transport layer of the
+// HTTP protocol.
+//
+// These timeouts are separate from any the user may use to bound an
+// asynchronous call.
+type RequestOptions struct {
+	handle *witRuntime.Handle
+}
+
+func (self *RequestOptions) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *RequestOptions) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *RequestOptions) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *RequestOptions) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropRequestOptions(handle)
+	}
+}
+
+func RequestOptionsFromOwnHandle(handleValue int32) *RequestOptions {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &RequestOptions{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropRequestOptions(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func RequestOptionsFromBorrowHandle(handleValue int32) *RequestOptions {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &RequestOptions{handle}
+}
+
+// This type corresponds to the HTTP standard Status Code.
+type StatusCode = uint16
+
+//go:wasmimport wasi:http/types@0.3.0 [resource-drop]response
+func resourceDropResponse(handle int32)
+
+// Represents an HTTP Response.
+type Response struct {
+	handle *witRuntime.Handle
+}
+
+func (self *Response) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *Response) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *Response) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *Response) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropResponse(handle)
+	}
+}
+
+func ResponseFromOwnHandle(handleValue int32) *Response {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &Response{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropResponse(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func ResponseFromBorrowHandle(handleValue int32) *Response {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &Response{handle}
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [constructor]fields
+func wasm_import_constructor_fields() int32
+
+func MakeFields() *Fields {
+
+	result := wasm_import_constructor_fields()
+	return FieldsFromOwnHandle(int32(uintptr(result)))
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [static]fields.from-list
+func wasm_import_static_fields_from_list(arg0 uintptr, arg1 uint32, arg2 uintptr)
+
+func FieldsFromList(entries []witTypes.Tuple2[string, []uint8]) witTypes.Result[*Fields, HeaderError] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	slice := entries
+	length := uint32(len(slice))
+	result := witRuntime.Allocate(pinner, uintptr(length*(4*4)), 4)
+	for index, element := range slice {
+		base := unsafe.Add(result, index*(4*4))
+		utf8 := unsafe.Pointer(unsafe.StringData((element).F0))
+		pinner.Pin(utf8)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).F0)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8)))
+		data := unsafe.Pointer(unsafe.SliceData((element).F1))
+		pinner.Pin(data)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).F1)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(data)))
+
+	}
+
+	wasm_import_static_fields_from_list(uintptr(result), length, returnArea)
+	var result0 witTypes.Result[*Fields, HeaderError]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result0 = witTypes.Ok[*Fields, HeaderError](FieldsFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+		var variant HeaderError
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+
+			variant = MakeHeaderErrorInvalidSyntax()
+
+		case 1:
+
+			variant = MakeHeaderErrorForbidden()
+
+		case 2:
+
+			variant = MakeHeaderErrorImmutable()
+
+		case 3:
+
+			variant = MakeHeaderErrorSizeExceeded()
+
+		case 4:
+			var option witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+
+				option = witTypes.None[string]()
+			case 1:
+				value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				option = witTypes.Some[string](value)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeHeaderErrorOther(option)
+
+		default:
+			panic("unreachable")
+		}
+
+		result0 = witTypes.Err[*Fields, HeaderError](variant)
+	default:
+		panic("unreachable")
+	}
+	result1 := result0
+	return result1
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]fields.get
+func wasm_import_method_fields_get(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
+
+func (self *Fields) Get(name string) [][]uint8 {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	wasm_import_method_fields_get((self).Handle(), uintptr(utf8), uint32(len(name)), returnArea)
+	result := make([][]uint8, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)))), index*(2*4))
+		value := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+		result = append(result, value)
+	}
+
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]fields.has
+func wasm_import_method_fields_has(arg0 int32, arg1 uintptr, arg2 uint32) int32
+
+func (self *Fields) Has(name string) bool {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	result := wasm_import_method_fields_has((self).Handle(), uintptr(utf8), uint32(len(name)))
+	return (result != 0)
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]fields.set
+func wasm_import_method_fields_set(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *Fields) Set(name string, value [][]uint8) witTypes.Result[witTypes.Unit, HeaderError] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	slice := value
+	length := uint32(len(slice))
+	result := witRuntime.Allocate(pinner, uintptr(length*(2*4)), 4)
+	for index, element := range slice {
+		base := unsafe.Add(result, index*(2*4))
+		data := unsafe.Pointer(unsafe.SliceData(element))
+		pinner.Pin(data)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(data)))
+
+	}
+
+	wasm_import_method_fields_set((self).Handle(), uintptr(utf8), uint32(len(name)), uintptr(result), length, returnArea)
+	var result1 witTypes.Result[witTypes.Unit, HeaderError]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result1 = witTypes.Ok[witTypes.Unit, HeaderError](witTypes.Unit{})
+	case 1:
+		var variant HeaderError
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+
+			variant = MakeHeaderErrorInvalidSyntax()
+
+		case 1:
+
+			variant = MakeHeaderErrorForbidden()
+
+		case 2:
+
+			variant = MakeHeaderErrorImmutable()
+
+		case 3:
+
+			variant = MakeHeaderErrorSizeExceeded()
+
+		case 4:
+			var option witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+
+				option = witTypes.None[string]()
+			case 1:
+				value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				option = witTypes.Some[string](value0)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeHeaderErrorOther(option)
+
+		default:
+			panic("unreachable")
+		}
+
+		result1 = witTypes.Err[witTypes.Unit, HeaderError](variant)
+	default:
+		panic("unreachable")
+	}
+	result2 := result1
+	return result2
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]fields.delete
+func wasm_import_method_fields_delete(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
+
+func (self *Fields) Delete(name string) witTypes.Result[witTypes.Unit, HeaderError] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	wasm_import_method_fields_delete((self).Handle(), uintptr(utf8), uint32(len(name)), returnArea)
+	var result witTypes.Result[witTypes.Unit, HeaderError]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, HeaderError](witTypes.Unit{})
+	case 1:
+		var variant HeaderError
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+
+			variant = MakeHeaderErrorInvalidSyntax()
+
+		case 1:
+
+			variant = MakeHeaderErrorForbidden()
+
+		case 2:
+
+			variant = MakeHeaderErrorImmutable()
+
+		case 3:
+
+			variant = MakeHeaderErrorSizeExceeded()
+
+		case 4:
+			var option witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+
+				option = witTypes.None[string]()
+			case 1:
+				value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				option = witTypes.Some[string](value)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeHeaderErrorOther(option)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Unit, HeaderError](variant)
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]fields.get-and-delete
+func wasm_import_method_fields_get_and_delete(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
+
+func (self *Fields) GetAndDelete(name string) witTypes.Result[[][]uint8, HeaderError] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	wasm_import_method_fields_get_and_delete((self).Handle(), uintptr(utf8), uint32(len(name)), returnArea)
+	var result1 witTypes.Result[[][]uint8, HeaderError]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		result := make([][]uint8, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(2*4))
+			value := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+			result = append(result, value)
+		}
+
+		result1 = witTypes.Ok[[][]uint8, HeaderError](result)
+	case 1:
+		var variant HeaderError
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+
+			variant = MakeHeaderErrorInvalidSyntax()
+
+		case 1:
+
+			variant = MakeHeaderErrorForbidden()
+
+		case 2:
+
+			variant = MakeHeaderErrorImmutable()
+
+		case 3:
+
+			variant = MakeHeaderErrorSizeExceeded()
+
+		case 4:
+			var option witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+
+				option = witTypes.None[string]()
+			case 1:
+				value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				option = witTypes.Some[string](value0)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeHeaderErrorOther(option)
+
+		default:
+			panic("unreachable")
+		}
+
+		result1 = witTypes.Err[[][]uint8, HeaderError](variant)
+	default:
+		panic("unreachable")
+	}
+	result2 := result1
+	return result2
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]fields.append
+func wasm_import_method_fields_append(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 uintptr)
+
+func (self *Fields) Append(name string, value []uint8) witTypes.Result[witTypes.Unit, HeaderError] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	data := unsafe.Pointer(unsafe.SliceData(value))
+	pinner.Pin(data)
+	wasm_import_method_fields_append((self).Handle(), uintptr(utf8), uint32(len(name)), uintptr(data), uint32(len(value)), returnArea)
+	var result witTypes.Result[witTypes.Unit, HeaderError]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, HeaderError](witTypes.Unit{})
+	case 1:
+		var variant HeaderError
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+
+			variant = MakeHeaderErrorInvalidSyntax()
+
+		case 1:
+
+			variant = MakeHeaderErrorForbidden()
+
+		case 2:
+
+			variant = MakeHeaderErrorImmutable()
+
+		case 3:
+
+			variant = MakeHeaderErrorSizeExceeded()
+
+		case 4:
+			var option witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+
+				option = witTypes.None[string]()
+			case 1:
+				value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				option = witTypes.Some[string](value0)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeHeaderErrorOther(option)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Unit, HeaderError](variant)
+	default:
+		panic("unreachable")
+	}
+	result1 := result
+	return result1
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]fields.copy-all
+func wasm_import_method_fields_copy_all(arg0 int32, arg1 uintptr)
+
+func (self *Fields) CopyAll() []witTypes.Tuple2[string, []uint8] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	wasm_import_method_fields_copy_all((self).Handle(), returnArea)
+	result := make([]witTypes.Tuple2[string, []uint8], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))); index++ {
+		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)))), index*(4*4))
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+		value0 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))))
+
+		result = append(result, witTypes.Tuple2[string, []uint8]{value, value0})
+	}
+
+	result1 := result
+	return result1
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]fields.clone
+func wasm_import_method_fields_clone(arg0 int32) int32
+
+func (self *Fields) Clone() *Fields {
+
+	result := wasm_import_method_fields_clone((self).Handle())
+	return FieldsFromOwnHandle(int32(uintptr(result)))
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [static]request.new
+func wasm_import_static_request_new(arg0 int32, arg1 int32, arg2 int32, arg3 int32, arg4 int32, arg5 int32, arg6 uintptr)
+
+func RequestNew(headers *Fields, contents witTypes.Option[*witTypes.StreamReader[uint8]], trailers *witTypes.FutureReader[witTypes.Result[witTypes.Option[*Fields], ErrorCode]], options witTypes.Option[*RequestOptions]) (*Request, *witTypes.FutureReader[witTypes.Result[witTypes.Unit, ErrorCode]]) {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
+	var option int32
+	var option0 int32
+	switch contents.Tag() {
+	case witTypes.OptionNone:
+
+		option = int32(0)
+		option0 = 0
+	case witTypes.OptionSome:
+		payload := contents.Some()
+
+		option = int32(1)
+		option0 = (payload).TakeHandle()
+	default:
+		panic("unreachable")
+	}
+	var option1 int32
+	var option2 int32
+	switch options.Tag() {
+	case witTypes.OptionNone:
+
+		option1 = int32(0)
+		option2 = 0
+	case witTypes.OptionSome:
+		payload := options.Some()
+
+		option1 = int32(1)
+		option2 = (payload).TakeHandle()
+	default:
+		panic("unreachable")
+	}
+	wasm_import_static_request_new((headers).TakeHandle(), option, option0, (trailers).TakeHandle(), option1, option2, returnArea)
+	result := witTypes.Tuple2[*Request, *witTypes.FutureReader[witTypes.Result[witTypes.Unit, ErrorCode]]]{RequestFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), LiftFutureResultUnitErrorCode(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))}
+	tuple := result
+	return tuple.F0, tuple.F1
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request.get-method
+func wasm_import_method_request_get_method(arg0 int32, arg1 uintptr)
+
+func (self *Request) GetMethod() Method {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_method_request_get_method((self).Handle(), returnArea)
+	var variant Method
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		variant = MakeMethodGet()
+
+	case 1:
+
+		variant = MakeMethodHead()
+
+	case 2:
+
+		variant = MakeMethodPost()
+
+	case 3:
+
+		variant = MakeMethodPut()
+
+	case 4:
+
+		variant = MakeMethodDelete()
+
+	case 5:
+
+		variant = MakeMethodConnect()
+
+	case 6:
+
+		variant = MakeMethodOptions()
+
+	case 7:
+
+		variant = MakeMethodTrace()
+
+	case 8:
+
+		variant = MakeMethodPatch()
+
+	case 9:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		variant = MakeMethodOther(value)
+
+	default:
+		panic("unreachable")
+	}
+	result := variant
+	return result
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request.set-method
+func wasm_import_method_request_set_method(arg0 int32, arg1 int32, arg2 uintptr, arg3 uint32) int32
+
+func (self *Request) SetMethod(method Method) witTypes.Result[witTypes.Unit, witTypes.Unit] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	var variant int32
+	var variant0 uintptr
+	var variant1 uint32
+	switch method.Tag() {
+	case MethodGet:
+
+		variant = int32(0)
+		variant0 = 0
+		variant1 = 0
+
+	case MethodHead:
+
+		variant = int32(1)
+		variant0 = 0
+		variant1 = 0
+
+	case MethodPost:
+
+		variant = int32(2)
+		variant0 = 0
+		variant1 = 0
+
+	case MethodPut:
+
+		variant = int32(3)
+		variant0 = 0
+		variant1 = 0
+
+	case MethodDelete:
+
+		variant = int32(4)
+		variant0 = 0
+		variant1 = 0
+
+	case MethodConnect:
+
+		variant = int32(5)
+		variant0 = 0
+		variant1 = 0
+
+	case MethodOptions:
+
+		variant = int32(6)
+		variant0 = 0
+		variant1 = 0
+
+	case MethodTrace:
+
+		variant = int32(7)
+		variant0 = 0
+		variant1 = 0
+
+	case MethodPatch:
+
+		variant = int32(8)
+		variant0 = 0
+		variant1 = 0
+
+	case MethodOther:
+		payload := method.Other()
+		utf8 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf8)
+
+		variant = int32(9)
+		variant0 = uintptr(utf8)
+		variant1 = uint32(len(payload))
+
+	default:
+		panic("unreachable")
+	}
+	result := wasm_import_method_request_set_method((self).Handle(), variant, variant0, variant1)
+	var result2 witTypes.Result[witTypes.Unit, witTypes.Unit]
+	switch result {
+	case 0:
+
+		result2 = witTypes.Ok[witTypes.Unit, witTypes.Unit](witTypes.Unit{})
+	case 1:
+
+		result2 = witTypes.Err[witTypes.Unit, witTypes.Unit](witTypes.Unit{})
+	default:
+		panic("unreachable")
+	}
+	return result2
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request.get-path-with-query
+func wasm_import_method_request_get_path_with_query(arg0 int32, arg1 uintptr)
+
+func (self *Request) GetPathWithQuery() witTypes.Option[string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_method_request_get_path_with_query((self).Handle(), returnArea)
+	var option witTypes.Option[string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[string]()
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		option = witTypes.Some[string](value)
+	default:
+		panic("unreachable")
+	}
+	result := option
+	return result
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request.set-path-with-query
+func wasm_import_method_request_set_path_with_query(arg0 int32, arg1 int32, arg2 uintptr, arg3 uint32) int32
+
+func (self *Request) SetPathWithQuery(pathWithQuery witTypes.Option[string]) witTypes.Result[witTypes.Unit, witTypes.Unit] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	var option int32
+	var option0 uintptr
+	var option1 uint32
+	switch pathWithQuery.Tag() {
+	case witTypes.OptionNone:
+
+		option = int32(0)
+		option0 = 0
+		option1 = 0
+	case witTypes.OptionSome:
+		payload := pathWithQuery.Some()
+		utf8 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf8)
+
+		option = int32(1)
+		option0 = uintptr(utf8)
+		option1 = uint32(len(payload))
+	default:
+		panic("unreachable")
+	}
+	result := wasm_import_method_request_set_path_with_query((self).Handle(), option, option0, option1)
+	var result2 witTypes.Result[witTypes.Unit, witTypes.Unit]
+	switch result {
+	case 0:
+
+		result2 = witTypes.Ok[witTypes.Unit, witTypes.Unit](witTypes.Unit{})
+	case 1:
+
+		result2 = witTypes.Err[witTypes.Unit, witTypes.Unit](witTypes.Unit{})
+	default:
+		panic("unreachable")
+	}
+	return result2
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request.get-scheme
+func wasm_import_method_request_get_scheme(arg0 int32, arg1 uintptr)
+
+func (self *Request) GetScheme() witTypes.Option[Scheme] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
+	wasm_import_method_request_get_scheme((self).Handle(), returnArea)
+	var option witTypes.Option[Scheme]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[Scheme]()
+	case 1:
+		var variant Scheme
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+
+			variant = MakeSchemeHttp()
+
+		case 1:
+
+			variant = MakeSchemeHttps()
+
+		case 2:
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4))))
+
+			variant = MakeSchemeOther(value)
+
+		default:
+			panic("unreachable")
+		}
+
+		option = witTypes.Some[Scheme](variant)
+	default:
+		panic("unreachable")
+	}
+	result := option
+	return result
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request.set-scheme
+func wasm_import_method_request_set_scheme(arg0 int32, arg1 int32, arg2 int32, arg3 uintptr, arg4 uint32) int32
+
+func (self *Request) SetScheme(scheme witTypes.Option[Scheme]) witTypes.Result[witTypes.Unit, witTypes.Unit] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	var option int32
+	var option2 int32
+	var option3 uintptr
+	var option4 uint32
+	switch scheme.Tag() {
+	case witTypes.OptionNone:
+
+		option = int32(0)
+		option2 = 0
+		option3 = 0
+		option4 = 0
+	case witTypes.OptionSome:
+		payload := scheme.Some()
+		var variant int32
+		var variant0 uintptr
+		var variant1 uint32
+		switch payload.Tag() {
+		case SchemeHttp:
+
+			variant = int32(0)
+			variant0 = 0
+			variant1 = 0
+
+		case SchemeHttps:
+
+			variant = int32(1)
+			variant0 = 0
+			variant1 = 0
+
+		case SchemeOther:
+			payload := payload.Other()
+			utf8 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8)
+
+			variant = int32(2)
+			variant0 = uintptr(utf8)
+			variant1 = uint32(len(payload))
+
+		default:
+			panic("unreachable")
+		}
+
+		option = int32(1)
+		option2 = variant
+		option3 = variant0
+		option4 = variant1
+	default:
+		panic("unreachable")
+	}
+	result := wasm_import_method_request_set_scheme((self).Handle(), option, option2, option3, option4)
+	var result5 witTypes.Result[witTypes.Unit, witTypes.Unit]
+	switch result {
+	case 0:
+
+		result5 = witTypes.Ok[witTypes.Unit, witTypes.Unit](witTypes.Unit{})
+	case 1:
+
+		result5 = witTypes.Err[witTypes.Unit, witTypes.Unit](witTypes.Unit{})
+	default:
+		panic("unreachable")
+	}
+	return result5
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request.get-authority
+func wasm_import_method_request_get_authority(arg0 int32, arg1 uintptr)
+
+func (self *Request) GetAuthority() witTypes.Option[string] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_method_request_get_authority((self).Handle(), returnArea)
+	var option witTypes.Option[string]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[string]()
+	case 1:
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		option = witTypes.Some[string](value)
+	default:
+		panic("unreachable")
+	}
+	result := option
+	return result
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request.set-authority
+func wasm_import_method_request_set_authority(arg0 int32, arg1 int32, arg2 uintptr, arg3 uint32) int32
+
+func (self *Request) SetAuthority(authority witTypes.Option[string]) witTypes.Result[witTypes.Unit, witTypes.Unit] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	var option int32
+	var option0 uintptr
+	var option1 uint32
+	switch authority.Tag() {
+	case witTypes.OptionNone:
+
+		option = int32(0)
+		option0 = 0
+		option1 = 0
+	case witTypes.OptionSome:
+		payload := authority.Some()
+		utf8 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf8)
+
+		option = int32(1)
+		option0 = uintptr(utf8)
+		option1 = uint32(len(payload))
+	default:
+		panic("unreachable")
+	}
+	result := wasm_import_method_request_set_authority((self).Handle(), option, option0, option1)
+	var result2 witTypes.Result[witTypes.Unit, witTypes.Unit]
+	switch result {
+	case 0:
+
+		result2 = witTypes.Ok[witTypes.Unit, witTypes.Unit](witTypes.Unit{})
+	case 1:
+
+		result2 = witTypes.Err[witTypes.Unit, witTypes.Unit](witTypes.Unit{})
+	default:
+		panic("unreachable")
+	}
+	return result2
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request.get-options
+func wasm_import_method_request_get_options(arg0 int32, arg1 uintptr)
+
+func (self *Request) GetOptions() witTypes.Option[*RequestOptions] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
+	wasm_import_method_request_get_options((self).Handle(), returnArea)
+	var option witTypes.Option[*RequestOptions]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[*RequestOptions]()
+	case 1:
+
+		option = witTypes.Some[*RequestOptions](RequestOptionsFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	default:
+		panic("unreachable")
+	}
+	result := option
+	return result
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request.get-headers
+func wasm_import_method_request_get_headers(arg0 int32) int32
+
+func (self *Request) GetHeaders() *Fields {
+
+	result := wasm_import_method_request_get_headers((self).Handle())
+	return FieldsFromOwnHandle(int32(uintptr(result)))
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [static]request.consume-body
+func wasm_import_static_request_consume_body(arg0 int32, arg1 int32, arg2 uintptr)
+
+func RequestConsumeBody(this *Request, res *witTypes.FutureReader[witTypes.Result[witTypes.Unit, ErrorCode]]) (*witTypes.StreamReader[uint8], *witTypes.FutureReader[witTypes.Result[witTypes.Option[*Fields], ErrorCode]]) {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
+	wasm_import_static_request_consume_body((this).TakeHandle(), (res).TakeHandle(), returnArea)
+	result := witTypes.Tuple2[*witTypes.StreamReader[uint8], *witTypes.FutureReader[witTypes.Result[witTypes.Option[*Fields], ErrorCode]]]{LiftStreamU8(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 0))), LiftFutureResultOptionFieldsErrorCode(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))}
+	tuple := result
+	return tuple.F0, tuple.F1
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [constructor]request-options
+func wasm_import_constructor_request_options() int32
+
+func MakeRequestOptions() *RequestOptions {
+
+	result := wasm_import_constructor_request_options()
+	return RequestOptionsFromOwnHandle(int32(uintptr(result)))
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request-options.get-connect-timeout
+func wasm_import_method_request_options_get_connect_timeout(arg0 int32, arg1 uintptr)
+
+func (self *RequestOptions) GetConnectTimeout() witTypes.Option[uint64] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 16, 8))
+	wasm_import_method_request_options_get_connect_timeout((self).Handle(), returnArea)
+	var option witTypes.Option[uint64]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[uint64]()
+	case 1:
+
+		option = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))))
+	default:
+		panic("unreachable")
+	}
+	result := option
+	return result
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request-options.set-connect-timeout
+func wasm_import_method_request_options_set_connect_timeout(arg0 int32, arg1 int32, arg2 int64, arg3 uintptr)
+
+func (self *RequestOptions) SetConnectTimeout(duration witTypes.Option[uint64]) witTypes.Result[witTypes.Unit, RequestOptionsError] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	var option int32
+	var option0 int64
+	switch duration.Tag() {
+	case witTypes.OptionNone:
+
+		option = int32(0)
+		option0 = 0
+	case witTypes.OptionSome:
+		payload := duration.Some()
+
+		option = int32(1)
+		option0 = int64(payload)
+	default:
+		panic("unreachable")
+	}
+	wasm_import_method_request_options_set_connect_timeout((self).Handle(), option, option0, returnArea)
+	var result witTypes.Result[witTypes.Unit, RequestOptionsError]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, RequestOptionsError](witTypes.Unit{})
+	case 1:
+		var variant RequestOptionsError
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+
+			variant = MakeRequestOptionsErrorNotSupported()
+
+		case 1:
+
+			variant = MakeRequestOptionsErrorImmutable()
+
+		case 2:
+			var option1 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+
+				option1 = witTypes.None[string]()
+			case 1:
+				value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				option1 = witTypes.Some[string](value)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeRequestOptionsErrorOther(option1)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Unit, RequestOptionsError](variant)
+	default:
+		panic("unreachable")
+	}
+	result2 := result
+	return result2
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request-options.get-first-byte-timeout
+func wasm_import_method_request_options_get_first_byte_timeout(arg0 int32, arg1 uintptr)
+
+func (self *RequestOptions) GetFirstByteTimeout() witTypes.Option[uint64] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 16, 8))
+	wasm_import_method_request_options_get_first_byte_timeout((self).Handle(), returnArea)
+	var option witTypes.Option[uint64]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[uint64]()
+	case 1:
+
+		option = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))))
+	default:
+		panic("unreachable")
+	}
+	result := option
+	return result
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request-options.set-first-byte-timeout
+func wasm_import_method_request_options_set_first_byte_timeout(arg0 int32, arg1 int32, arg2 int64, arg3 uintptr)
+
+func (self *RequestOptions) SetFirstByteTimeout(duration witTypes.Option[uint64]) witTypes.Result[witTypes.Unit, RequestOptionsError] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	var option int32
+	var option0 int64
+	switch duration.Tag() {
+	case witTypes.OptionNone:
+
+		option = int32(0)
+		option0 = 0
+	case witTypes.OptionSome:
+		payload := duration.Some()
+
+		option = int32(1)
+		option0 = int64(payload)
+	default:
+		panic("unreachable")
+	}
+	wasm_import_method_request_options_set_first_byte_timeout((self).Handle(), option, option0, returnArea)
+	var result witTypes.Result[witTypes.Unit, RequestOptionsError]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, RequestOptionsError](witTypes.Unit{})
+	case 1:
+		var variant RequestOptionsError
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+
+			variant = MakeRequestOptionsErrorNotSupported()
+
+		case 1:
+
+			variant = MakeRequestOptionsErrorImmutable()
+
+		case 2:
+			var option1 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+
+				option1 = witTypes.None[string]()
+			case 1:
+				value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				option1 = witTypes.Some[string](value)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeRequestOptionsErrorOther(option1)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Unit, RequestOptionsError](variant)
+	default:
+		panic("unreachable")
+	}
+	result2 := result
+	return result2
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request-options.get-between-bytes-timeout
+func wasm_import_method_request_options_get_between_bytes_timeout(arg0 int32, arg1 uintptr)
+
+func (self *RequestOptions) GetBetweenBytesTimeout() witTypes.Option[uint64] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 16, 8))
+	wasm_import_method_request_options_get_between_bytes_timeout((self).Handle(), returnArea)
+	var option witTypes.Option[uint64]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		option = witTypes.None[uint64]()
+	case 1:
+
+		option = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))))
+	default:
+		panic("unreachable")
+	}
+	result := option
+	return result
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request-options.set-between-bytes-timeout
+func wasm_import_method_request_options_set_between_bytes_timeout(arg0 int32, arg1 int32, arg2 int64, arg3 uintptr)
+
+func (self *RequestOptions) SetBetweenBytesTimeout(duration witTypes.Option[uint64]) witTypes.Result[witTypes.Unit, RequestOptionsError] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (5 * 4), 4))
+	var option int32
+	var option0 int64
+	switch duration.Tag() {
+	case witTypes.OptionNone:
+
+		option = int32(0)
+		option0 = 0
+	case witTypes.OptionSome:
+		payload := duration.Some()
+
+		option = int32(1)
+		option0 = int64(payload)
+	default:
+		panic("unreachable")
+	}
+	wasm_import_method_request_options_set_between_bytes_timeout((self).Handle(), option, option0, returnArea)
+	var result witTypes.Result[witTypes.Unit, RequestOptionsError]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, RequestOptionsError](witTypes.Unit{})
+	case 1:
+		var variant RequestOptionsError
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+
+			variant = MakeRequestOptionsErrorNotSupported()
+
+		case 1:
+
+			variant = MakeRequestOptionsErrorImmutable()
+
+		case 2:
+			var option1 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) {
+			case 0:
+
+				option1 = witTypes.None[string]()
+			case 1:
+				value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))
+
+				option1 = witTypes.Some[string](value)
+			default:
+				panic("unreachable")
+			}
+
+			variant = MakeRequestOptionsErrorOther(option1)
+
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Err[witTypes.Unit, RequestOptionsError](variant)
+	default:
+		panic("unreachable")
+	}
+	result2 := result
+	return result2
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]request-options.clone
+func wasm_import_method_request_options_clone(arg0 int32) int32
+
+func (self *RequestOptions) Clone() *RequestOptions {
+
+	result := wasm_import_method_request_options_clone((self).Handle())
+	return RequestOptionsFromOwnHandle(int32(uintptr(result)))
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [static]response.new
+func wasm_import_static_response_new(arg0 int32, arg1 int32, arg2 int32, arg3 int32, arg4 uintptr)
+
+func ResponseNew(headers *Fields, contents witTypes.Option[*witTypes.StreamReader[uint8]], trailers *witTypes.FutureReader[witTypes.Result[witTypes.Option[*Fields], ErrorCode]]) (*Response, *witTypes.FutureReader[witTypes.Result[witTypes.Unit, ErrorCode]]) {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
+	var option int32
+	var option0 int32
+	switch contents.Tag() {
+	case witTypes.OptionNone:
+
+		option = int32(0)
+		option0 = 0
+	case witTypes.OptionSome:
+		payload := contents.Some()
+
+		option = int32(1)
+		option0 = (payload).TakeHandle()
+	default:
+		panic("unreachable")
+	}
+	wasm_import_static_response_new((headers).TakeHandle(), option, option0, (trailers).TakeHandle(), returnArea)
+	result := witTypes.Tuple2[*Response, *witTypes.FutureReader[witTypes.Result[witTypes.Unit, ErrorCode]]]{ResponseFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), LiftFutureResultUnitErrorCode(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))}
+	tuple := result
+	return tuple.F0, tuple.F1
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]response.get-status-code
+func wasm_import_method_response_get_status_code(arg0 int32) int32
+
+func (self *Response) GetStatusCode() uint16 {
+
+	result := wasm_import_method_response_get_status_code((self).Handle())
+	return uint16(result)
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]response.set-status-code
+func wasm_import_method_response_set_status_code(arg0 int32, arg1 int32) int32
+
+func (self *Response) SetStatusCode(statusCode uint16) witTypes.Result[witTypes.Unit, witTypes.Unit] {
+
+	result := wasm_import_method_response_set_status_code((self).Handle(), int32(statusCode))
+	var result0 witTypes.Result[witTypes.Unit, witTypes.Unit]
+	switch result {
+	case 0:
+
+		result0 = witTypes.Ok[witTypes.Unit, witTypes.Unit](witTypes.Unit{})
+	case 1:
+
+		result0 = witTypes.Err[witTypes.Unit, witTypes.Unit](witTypes.Unit{})
+	default:
+		panic("unreachable")
+	}
+	return result0
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [method]response.get-headers
+func wasm_import_method_response_get_headers(arg0 int32) int32
+
+func (self *Response) GetHeaders() *Fields {
+
+	result := wasm_import_method_response_get_headers((self).Handle())
+	return FieldsFromOwnHandle(int32(uintptr(result)))
+
+}
+
+//go:wasmimport wasi:http/types@0.3.0 [static]response.consume-body
+func wasm_import_static_response_consume_body(arg0 int32, arg1 int32, arg2 uintptr)
+
+func ResponseConsumeBody(this *Response, res *witTypes.FutureReader[witTypes.Result[witTypes.Unit, ErrorCode]]) (*witTypes.StreamReader[uint8], *witTypes.FutureReader[witTypes.Result[witTypes.Option[*Fields], ErrorCode]]) {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
+	wasm_import_static_response_consume_body((this).TakeHandle(), (res).TakeHandle(), returnArea)
+	result := witTypes.Tuple2[*witTypes.StreamReader[uint8], *witTypes.FutureReader[witTypes.Result[witTypes.Option[*Fields], ErrorCode]]]{LiftStreamU8(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 0))), LiftFutureResultOptionFieldsErrorCode(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))}
+	tuple := result
+	return tuple.F0, tuple.F1
+
+}
diff --git a/sdks/go/golem/internal/wit/wasi_keyvalue_eventual/empty.s b/sdks/go/golem/internal/wit/wasi_keyvalue_eventual/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_keyvalue_eventual/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/wasi_keyvalue_eventual/wit_bindings.go b/sdks/go/golem/internal/wit/wasi_keyvalue_eventual/wit_bindings.go
new file mode 100644
index 0000000000..baf347f1ab
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_keyvalue_eventual/wit_bindings.go
@@ -0,0 +1,166 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package wasi_keyvalue_eventual
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_keyvalue_types"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_keyvalue_wasi_keyvalue_error"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type Bucket = wasi_keyvalue_types.Bucket
+type Error = wasi_keyvalue_wasi_keyvalue_error.Error
+type IncomingValue = wasi_keyvalue_types.IncomingValue
+type Key = string
+type OutgoingValue = wasi_keyvalue_types.OutgoingValue
+
+//go:wasmimport wasi:keyvalue/eventual@0.1.0 get
+func wasm_import_get(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
+
+func Get(bucket *wasi_keyvalue_types.Bucket, key string) witTypes.Result[witTypes.Option[*wasi_keyvalue_types.IncomingValue], *wasi_keyvalue_wasi_keyvalue_error.Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 12, 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(key))
+	pinner.Pin(utf8)
+	wasm_import_get((bucket).Handle(), uintptr(utf8), uint32(len(key)), returnArea)
+	var result witTypes.Result[witTypes.Option[*wasi_keyvalue_types.IncomingValue], *wasi_keyvalue_wasi_keyvalue_error.Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		var option witTypes.Option[*wasi_keyvalue_types.IncomingValue]
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) {
+		case 0:
+
+			option = witTypes.None[*wasi_keyvalue_types.IncomingValue]()
+		case 1:
+
+			option = witTypes.Some[*wasi_keyvalue_types.IncomingValue](wasi_keyvalue_types.IncomingValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))))
+		default:
+			panic("unreachable")
+		}
+
+		result = witTypes.Ok[witTypes.Option[*wasi_keyvalue_types.IncomingValue], *wasi_keyvalue_wasi_keyvalue_error.Error](option)
+	case 1:
+
+		result = witTypes.Err[witTypes.Option[*wasi_keyvalue_types.IncomingValue], *wasi_keyvalue_wasi_keyvalue_error.Error](wasi_keyvalue_wasi_keyvalue_error.ErrorFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:keyvalue/eventual@0.1.0 set
+func wasm_import_set(arg0 int32, arg1 uintptr, arg2 uint32, arg3 int32, arg4 uintptr)
+
+func Set(bucket *wasi_keyvalue_types.Bucket, key string, outgoingValue *wasi_keyvalue_types.OutgoingValue) witTypes.Result[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(key))
+	pinner.Pin(utf8)
+	wasm_import_set((bucket).Handle(), uintptr(utf8), uint32(len(key)), (outgoingValue).Handle(), returnArea)
+	var result witTypes.Result[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error](witTypes.Unit{})
+	case 1:
+
+		result = witTypes.Err[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error](wasi_keyvalue_wasi_keyvalue_error.ErrorFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:keyvalue/eventual@0.1.0 delete
+func wasm_import_delete(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
+
+func Delete(bucket *wasi_keyvalue_types.Bucket, key string) witTypes.Result[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(key))
+	pinner.Pin(utf8)
+	wasm_import_delete((bucket).Handle(), uintptr(utf8), uint32(len(key)), returnArea)
+	var result witTypes.Result[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error](witTypes.Unit{})
+	case 1:
+
+		result = witTypes.Err[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error](wasi_keyvalue_wasi_keyvalue_error.ErrorFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:keyvalue/eventual@0.1.0 exists
+func wasm_import_exists(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
+
+func Exists(bucket *wasi_keyvalue_types.Bucket, key string) witTypes.Result[bool, *wasi_keyvalue_wasi_keyvalue_error.Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(key))
+	pinner.Pin(utf8)
+	wasm_import_exists((bucket).Handle(), uintptr(utf8), uint32(len(key)), returnArea)
+	var result witTypes.Result[bool, *wasi_keyvalue_wasi_keyvalue_error.Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[bool, *wasi_keyvalue_wasi_keyvalue_error.Error]((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) != 0))
+	case 1:
+
+		result = witTypes.Err[bool, *wasi_keyvalue_wasi_keyvalue_error.Error](wasi_keyvalue_wasi_keyvalue_error.ErrorFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
diff --git a/sdks/go/golem/internal/wit/wasi_keyvalue_eventual_batch/empty.s b/sdks/go/golem/internal/wit/wasi_keyvalue_eventual_batch/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_keyvalue_eventual_batch/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/wasi_keyvalue_eventual_batch/wit_bindings.go b/sdks/go/golem/internal/wit/wasi_keyvalue_eventual_batch/wit_bindings.go
new file mode 100644
index 0000000000..3db07173a5
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_keyvalue_eventual_batch/wit_bindings.go
@@ -0,0 +1,208 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package wasi_keyvalue_eventual_batch
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_keyvalue_types"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_keyvalue_wasi_keyvalue_error"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+type Bucket = wasi_keyvalue_types.Bucket
+type Error = wasi_keyvalue_wasi_keyvalue_error.Error
+type Key = string
+type IncomingValue = wasi_keyvalue_types.IncomingValue
+type OutgoingValue = wasi_keyvalue_types.OutgoingValue
+
+//go:wasmimport wasi:keyvalue/eventual-batch@0.1.0 get-many
+func wasm_import_get_many(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
+
+func GetMany(bucket *wasi_keyvalue_types.Bucket, keys []string) witTypes.Result[[]witTypes.Option[*wasi_keyvalue_types.IncomingValue], *wasi_keyvalue_wasi_keyvalue_error.Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	slice := keys
+	length := uint32(len(slice))
+	result := witRuntime.Allocate(pinner, uintptr(length*(2*4)), 4)
+	for index, element := range slice {
+		base := unsafe.Add(result, index*(2*4))
+		utf8 := unsafe.Pointer(unsafe.StringData(element))
+		pinner.Pin(utf8)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8)))
+
+	}
+
+	wasm_import_get_many((bucket).Handle(), uintptr(result), length, returnArea)
+	var result1 witTypes.Result[[]witTypes.Option[*wasi_keyvalue_types.IncomingValue], *wasi_keyvalue_wasi_keyvalue_error.Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		result0 := make([]witTypes.Option[*wasi_keyvalue_types.IncomingValue], 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*8)
+			var option witTypes.Option[*wasi_keyvalue_types.IncomingValue]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+
+				option = witTypes.None[*wasi_keyvalue_types.IncomingValue]()
+			case 1:
+
+				option = witTypes.Some[*wasi_keyvalue_types.IncomingValue](wasi_keyvalue_types.IncomingValueFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4))))))
+			default:
+				panic("unreachable")
+			}
+
+			result0 = append(result0, option)
+		}
+
+		result1 = witTypes.Ok[[]witTypes.Option[*wasi_keyvalue_types.IncomingValue], *wasi_keyvalue_wasi_keyvalue_error.Error](result0)
+	case 1:
+
+		result1 = witTypes.Err[[]witTypes.Option[*wasi_keyvalue_types.IncomingValue], *wasi_keyvalue_wasi_keyvalue_error.Error](wasi_keyvalue_wasi_keyvalue_error.ErrorFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	default:
+		panic("unreachable")
+	}
+	result2 := result1
+	return result2
+
+}
+
+//go:wasmimport wasi:keyvalue/eventual-batch@0.1.0 keys
+func wasm_import_keys(arg0 int32, arg1 uintptr)
+
+func Keys(bucket *wasi_keyvalue_types.Bucket) witTypes.Result[[]string, *wasi_keyvalue_wasi_keyvalue_error.Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_keys((bucket).Handle(), returnArea)
+	var result0 witTypes.Result[[]string, *wasi_keyvalue_wasi_keyvalue_error.Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		result := make([]string, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))), index*(2*4))
+			value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)))
+
+			result = append(result, value)
+		}
+
+		result0 = witTypes.Ok[[]string, *wasi_keyvalue_wasi_keyvalue_error.Error](result)
+	case 1:
+
+		result0 = witTypes.Err[[]string, *wasi_keyvalue_wasi_keyvalue_error.Error](wasi_keyvalue_wasi_keyvalue_error.ErrorFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	default:
+		panic("unreachable")
+	}
+	result1 := result0
+	return result1
+
+}
+
+//go:wasmimport wasi:keyvalue/eventual-batch@0.1.0 set-many
+func wasm_import_set_many(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
+
+func SetMany(bucket *wasi_keyvalue_types.Bucket, keyValues []witTypes.Tuple2[string, *wasi_keyvalue_types.OutgoingValue]) witTypes.Result[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
+	slice := keyValues
+	length := uint32(len(slice))
+	result := witRuntime.Allocate(pinner, uintptr(length*(3*4)), 4)
+	for index, element := range slice {
+		base := unsafe.Add(result, index*(3*4))
+		utf8 := unsafe.Pointer(unsafe.StringData((element).F0))
+		pinner.Pin(utf8)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).F0)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8)))
+		*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = ((element).F1).Handle()
+
+	}
+
+	wasm_import_set_many((bucket).Handle(), uintptr(result), length, returnArea)
+	var result0 witTypes.Result[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result0 = witTypes.Ok[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error](witTypes.Unit{})
+	case 1:
+
+		result0 = witTypes.Err[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error](wasi_keyvalue_wasi_keyvalue_error.ErrorFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	default:
+		panic("unreachable")
+	}
+	result1 := result0
+	return result1
+
+}
+
+//go:wasmimport wasi:keyvalue/eventual-batch@0.1.0 delete-many
+func wasm_import_delete_many(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
+
+func DeleteMany(bucket *wasi_keyvalue_types.Bucket, keys []string) witTypes.Result[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
+	slice := keys
+	length := uint32(len(slice))
+	result := witRuntime.Allocate(pinner, uintptr(length*(2*4)), 4)
+	for index, element := range slice {
+		base := unsafe.Add(result, index*(2*4))
+		utf8 := unsafe.Pointer(unsafe.StringData(element))
+		pinner.Pin(utf8)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8)))
+
+	}
+
+	wasm_import_delete_many((bucket).Handle(), uintptr(result), length, returnArea)
+	var result0 witTypes.Result[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result0 = witTypes.Ok[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error](witTypes.Unit{})
+	case 1:
+
+		result0 = witTypes.Err[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error](wasi_keyvalue_wasi_keyvalue_error.ErrorFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	default:
+		panic("unreachable")
+	}
+	result1 := result0
+	return result1
+
+}
diff --git a/sdks/go/golem/internal/wit/wasi_keyvalue_types/empty.s b/sdks/go/golem/internal/wit/wasi_keyvalue_types/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_keyvalue_types/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/wasi_keyvalue_types/wit_bindings.go b/sdks/go/golem/internal/wit/wasi_keyvalue_types/wit_bindings.go
new file mode 100644
index 0000000000..26d6e5d260
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_keyvalue_types/wit_bindings.go
@@ -0,0 +1,409 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package wasi_keyvalue_types
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_keyvalue_wasi_keyvalue_error"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+//go:wasmimport wasi:keyvalue/types@0.1.0 [stream-new-0][method]outgoing-value.outgoing-value-write-body-async
+func wasm_stream_new_u8() uint64
+
+//go:wasmimport wasi:keyvalue/types@0.1.0 [async-lower][stream-read-0][method]outgoing-value.outgoing-value-write-body-async
+func wasm_stream_read_u8(handle int32, item unsafe.Pointer, count uint32) uint32
+
+//go:wasmimport wasi:keyvalue/types@0.1.0 [async-lower][stream-write-0][method]outgoing-value.outgoing-value-write-body-async
+func wasm_stream_write_u8(handle int32, item unsafe.Pointer, count uint32) uint32
+
+//go:wasmimport wasi:keyvalue/types@0.1.0 [stream-drop-readable-0][method]outgoing-value.outgoing-value-write-body-async
+func wasm_stream_drop_readable_u8(handle int32)
+
+//go:wasmimport wasi:keyvalue/types@0.1.0 [stream-drop-writable-0][method]outgoing-value.outgoing-value-write-body-async
+func wasm_stream_drop_writable_u8(handle int32)
+
+var wasm_stream_vtable_u8 = witTypes.StreamVtable[uint8]{
+	1,
+	1,
+	wasm_stream_read_u8,
+	wasm_stream_write_u8,
+	nil,
+	nil,
+	wasm_stream_drop_readable_u8,
+	wasm_stream_drop_writable_u8,
+	nil,
+	nil,
+}
+
+func MakeStreamU8() (*witTypes.StreamWriter[uint8], *witTypes.StreamReader[uint8]) {
+	pair := wasm_stream_new_u8()
+	return witTypes.MakeStreamWriter[uint8](&wasm_stream_vtable_u8, int32(pair>>32)),
+		witTypes.MakeStreamReader[uint8](&wasm_stream_vtable_u8, int32(pair&0xFFFFFFFF))
+}
+
+func LiftStreamU8(handle int32) *witTypes.StreamReader[uint8] {
+	return witTypes.MakeStreamReader[uint8](&wasm_stream_vtable_u8, handle)
+}
+
+type Error = wasi_keyvalue_wasi_keyvalue_error.Error
+
+//go:wasmimport wasi:keyvalue/types@0.1.0 [resource-drop]bucket
+func resourceDropBucket(handle int32)
+
+// A bucket is a collection of key-value pairs. Each key-value pair is stored
+// as a entry in the bucket, and the bucket itself acts as a collection of all
+// these entries.
+//
+// It is worth noting that the exact terminology for bucket in key-value stores
+// can very depending on the specific implementation. For example,
+// 1. Amazon DynamoDB calls a collection of key-value pairs a table
+// 2. Redis has hashes, sets, and sorted sets as different types of collections
+// 3. Cassandra calls a collection of key-value pairs a column family
+// 4. MongoDB calls a collection of key-value pairs a collection
+// 5. Riak calls a collection of key-value pairs a bucket
+// 6. Memcached calls a collection of key-value pairs a slab
+// 7. Azure Cosmos DB calls a collection of key-value pairs a container
+//
+// In this interface, we use the term `bucket` to refer to a collection of key-value
+// Soon: switch to `resource bucket { ... }`
+type Bucket struct {
+	handle *witRuntime.Handle
+}
+
+func (self *Bucket) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *Bucket) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *Bucket) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *Bucket) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropBucket(handle)
+	}
+}
+
+func BucketFromOwnHandle(handleValue int32) *Bucket {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &Bucket{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropBucket(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func BucketFromBorrowHandle(handleValue int32) *Bucket {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &Bucket{handle}
+}
+
+// A key is a unique identifier for a value in a bucket. The key is used to
+// retrieve the value from the bucket.
+type Key = string
+
+//go:wasmimport wasi:keyvalue/types@0.1.0 [resource-drop]outgoing-value
+func resourceDropOutgoingValue(handle int32)
+
+// A value is the data stored in a key-value pair. The value can be of any type
+// that can be represented in a byte array.
+// Soon: switch to `resource value { ... }`
+type OutgoingValue struct {
+	handle *witRuntime.Handle
+}
+
+func (self *OutgoingValue) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *OutgoingValue) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *OutgoingValue) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *OutgoingValue) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropOutgoingValue(handle)
+	}
+}
+
+func OutgoingValueFromOwnHandle(handleValue int32) *OutgoingValue {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &OutgoingValue{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropOutgoingValue(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func OutgoingValueFromBorrowHandle(handleValue int32) *OutgoingValue {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &OutgoingValue{handle}
+}
+
+//go:wasmimport wasi:keyvalue/types@0.1.0 [resource-drop]incoming-value
+func resourceDropIncomingValue(handle int32)
+
+// A incoming-value is a wrapper around a value. It provides ways to read the value.
+//
+// The incoming-value provides two ways to consume the value:
+//  1. `incoming-value-consume-sync` consumes the value synchronously and returns the
+//     value as a `list<u8>`.
+//  2. `incoming-value-consume-async` consumes the value asynchronously and returns the
+//     value as a `stream<u8>`.
+//
+// In addition, it provides a `incoming-value-size` function to get the size of the value.
+// This is useful when the value is large and the caller wants to allocate a buffer of
+// the right size to consume the value.
+// Soon: switch to `resource incoming-value { ... }`
+type IncomingValue struct {
+	handle *witRuntime.Handle
+}
+
+func (self *IncomingValue) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *IncomingValue) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *IncomingValue) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *IncomingValue) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropIncomingValue(handle)
+	}
+}
+
+func IncomingValueFromOwnHandle(handleValue int32) *IncomingValue {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &IncomingValue{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropIncomingValue(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func IncomingValueFromBorrowHandle(handleValue int32) *IncomingValue {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &IncomingValue{handle}
+}
+
+//go:wasmimport wasi:keyvalue/types@0.1.0 [static]bucket.open-bucket
+func wasm_import_static_bucket_open_bucket(arg0 uintptr, arg1 uint32, arg2 uintptr)
+
+func BucketOpenBucket(name string) witTypes.Result[*Bucket, *wasi_keyvalue_wasi_keyvalue_error.Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
+	utf8 := unsafe.Pointer(unsafe.StringData(name))
+	pinner.Pin(utf8)
+	wasm_import_static_bucket_open_bucket(uintptr(utf8), uint32(len(name)), returnArea)
+	var result witTypes.Result[*Bucket, *wasi_keyvalue_wasi_keyvalue_error.Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[*Bucket, *wasi_keyvalue_wasi_keyvalue_error.Error](BucketFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	case 1:
+
+		result = witTypes.Err[*Bucket, *wasi_keyvalue_wasi_keyvalue_error.Error](wasi_keyvalue_wasi_keyvalue_error.ErrorFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:keyvalue/types@0.1.0 [static]outgoing-value.new-outgoing-value
+func wasm_import_static_outgoing_value_new_outgoing_value() int32
+
+func OutgoingValueNewOutgoingValue() *OutgoingValue {
+
+	result := wasm_import_static_outgoing_value_new_outgoing_value()
+	return OutgoingValueFromOwnHandle(int32(uintptr(result)))
+
+}
+
+//go:wasmimport wasi:keyvalue/types@0.1.0 [method]outgoing-value.outgoing-value-write-body-async
+func wasm_import_method_outgoing_value_outgoing_value_write_body_async(arg0 int32, arg1 int32, arg2 uintptr)
+
+func (self *OutgoingValue) OutgoingValueWriteBodyAsync(data *witTypes.StreamReader[uint8]) witTypes.Result[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
+	wasm_import_method_outgoing_value_outgoing_value_write_body_async((self).Handle(), (data).TakeHandle(), returnArea)
+	var result witTypes.Result[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error](witTypes.Unit{})
+	case 1:
+
+		result = witTypes.Err[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error](wasi_keyvalue_wasi_keyvalue_error.ErrorFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:keyvalue/types@0.1.0 [method]outgoing-value.outgoing-value-write-body-sync
+func wasm_import_method_outgoing_value_outgoing_value_write_body_sync(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
+
+func (self *OutgoingValue) OutgoingValueWriteBodySync(value []uint8) witTypes.Result[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
+	data := unsafe.Pointer(unsafe.SliceData(value))
+	pinner.Pin(data)
+	wasm_import_method_outgoing_value_outgoing_value_write_body_sync((self).Handle(), uintptr(data), uint32(len(value)), returnArea)
+	var result witTypes.Result[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error](witTypes.Unit{})
+	case 1:
+
+		result = witTypes.Err[witTypes.Unit, *wasi_keyvalue_wasi_keyvalue_error.Error](wasi_keyvalue_wasi_keyvalue_error.ErrorFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:keyvalue/types@0.1.0 [method]incoming-value.incoming-value-consume-sync
+func wasm_import_method_incoming_value_incoming_value_consume_sync(arg0 int32, arg1 uintptr)
+
+func (self *IncomingValue) IncomingValueConsumeSync() witTypes.Result[[]uint8, *wasi_keyvalue_wasi_keyvalue_error.Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
+	wasm_import_method_incoming_value_incoming_value_consume_sync((self).Handle(), returnArea)
+	var result witTypes.Result[[]uint8, *wasi_keyvalue_wasi_keyvalue_error.Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+		value := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
+
+		result = witTypes.Ok[[]uint8, *wasi_keyvalue_wasi_keyvalue_error.Error](value)
+	case 1:
+
+		result = witTypes.Err[[]uint8, *wasi_keyvalue_wasi_keyvalue_error.Error](wasi_keyvalue_wasi_keyvalue_error.ErrorFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:keyvalue/types@0.1.0 [method]incoming-value.incoming-value-consume-async
+func wasm_import_method_incoming_value_incoming_value_consume_async(arg0 int32, arg1 uintptr)
+
+func (self *IncomingValue) IncomingValueConsumeAsync() witTypes.Result[*witTypes.StreamReader[uint8], *wasi_keyvalue_wasi_keyvalue_error.Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
+	wasm_import_method_incoming_value_incoming_value_consume_async((self).Handle(), returnArea)
+	var result witTypes.Result[*witTypes.StreamReader[uint8], *wasi_keyvalue_wasi_keyvalue_error.Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[*witTypes.StreamReader[uint8], *wasi_keyvalue_wasi_keyvalue_error.Error](LiftStreamU8(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))
+	case 1:
+
+		result = witTypes.Err[*witTypes.StreamReader[uint8], *wasi_keyvalue_wasi_keyvalue_error.Error](wasi_keyvalue_wasi_keyvalue_error.ErrorFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
+
+//go:wasmimport wasi:keyvalue/types@0.1.0 [method]incoming-value.incoming-value-size
+func wasm_import_method_incoming_value_incoming_value_size(arg0 int32, arg1 uintptr)
+
+func (self *IncomingValue) IncomingValueSize() witTypes.Result[uint64, *wasi_keyvalue_wasi_keyvalue_error.Error] {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, 16, 8))
+	wasm_import_method_incoming_value_incoming_value_size((self).Handle(), returnArea)
+	var result witTypes.Result[uint64, *wasi_keyvalue_wasi_keyvalue_error.Error]
+	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
+	case 0:
+
+		result = witTypes.Ok[uint64, *wasi_keyvalue_wasi_keyvalue_error.Error](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8))))
+	case 1:
+
+		result = witTypes.Err[uint64, *wasi_keyvalue_wasi_keyvalue_error.Error](wasi_keyvalue_wasi_keyvalue_error.ErrorFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))))
+	default:
+		panic("unreachable")
+	}
+	result0 := result
+	return result0
+
+}
diff --git a/sdks/go/golem/internal/wit/wasi_keyvalue_wasi_keyvalue_error/empty.s b/sdks/go/golem/internal/wit/wasi_keyvalue_wasi_keyvalue_error/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_keyvalue_wasi_keyvalue_error/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/wasi_keyvalue_wasi_keyvalue_error/wit_bindings.go b/sdks/go/golem/internal/wit/wasi_keyvalue_wasi_keyvalue_error/wit_bindings.go
new file mode 100644
index 0000000000..e14acf4334
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_keyvalue_wasi_keyvalue_error/wit_bindings.go
@@ -0,0 +1,111 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package wasi_keyvalue_wasi_keyvalue_error
+
+import (
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	"runtime"
+	"unsafe"
+)
+
+//go:wasmimport wasi:keyvalue/wasi-keyvalue-error@0.1.0 [resource-drop]error
+func resourceDropError(handle int32)
+
+// An error resource type for keyvalue operations.
+//
+// Common errors:
+//   - Connectivity errors (e.g. network errors): when the client cannot establish
+//     a connection to the keyvalue service.
+//   - Authentication and Authorization errors: when the client fails to authenticate
+//     or does not have the required permissions to perform the operation.
+//   - Data errors: when the client sends incompatible or corrupted data.
+//   - Resource errors: when the system runs out of resources (e.g. memory).
+//   - Internal errors: unexpected errors on the server side.
+//
+// Currently, this provides only one function to return a string representation
+// of the error. In the future, this will be extended to provide more information
+// about the error.
+// Soon: switch to `resource error { ... }`
+type Error struct {
+	handle *witRuntime.Handle
+}
+
+func (self *Error) TakeHandle() int32 {
+	return self.handle.Take()
+}
+
+func (self *Error) SetHandle(handle int32) {
+	self.handle.Set(handle)
+}
+
+func (self *Error) Handle() int32 {
+	return self.handle.Use()
+}
+
+func (self *Error) Drop() {
+	handle := self.handle.TakeOrNil()
+	if handle != 0 {
+		resourceDropError(handle)
+	}
+}
+
+func ErrorFromOwnHandle(handleValue int32) *Error {
+	handle := witRuntime.MakeHandle(handleValue)
+	value := &Error{handle}
+	runtime.AddCleanup(value, func(_ int) {
+		handleValue := handle.TakeOrNil()
+		if handleValue != 0 {
+			resourceDropError(handleValue)
+		}
+	}, 0)
+	return value
+}
+
+func ErrorFromBorrowHandle(handleValue int32) *Error {
+	handle := witRuntime.MakeHandle(handleValue)
+	return &Error{handle}
+}
+
+//go:wasmimport wasi:keyvalue/wasi-keyvalue-error@0.1.0 [method]error.trace
+func wasm_import_method_error_trace(arg0 int32, arg1 uintptr)
+
+func (self *Error) Trace() string {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
+	wasm_import_method_error_trace((self).Handle(), returnArea)
+	value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
+	result := value
+	return result
+
+}
diff --git a/sdks/go/golem/internal/wit/wasi_logging_logging/empty.s b/sdks/go/golem/internal/wit/wasi_logging_logging/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_logging_logging/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/wasi_logging_logging/wit_bindings.go b/sdks/go/golem/internal/wit/wasi_logging_logging/wit_bindings.go
new file mode 100644
index 0000000000..c677ca7bda
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wasi_logging_logging/wit_bindings.go
@@ -0,0 +1,73 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package wasi_logging_logging
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+const (
+	// Describes messages about the values of variables and the flow of
+	// control within a program.
+	LevelTrace uint8 = 0
+	// Describes messages likely to be of interest to someone debugging a
+	// program.
+	LevelDebug uint8 = 1
+	// Describes messages likely to be of interest to someone monitoring a
+	// program.
+	LevelInfo uint8 = 2
+	// Describes messages indicating hazardous situations.
+	LevelWarn uint8 = 3
+	// Describes messages indicating serious errors.
+	LevelError uint8 = 4
+	// Describes messages indicating fatal errors.
+	LevelCritical uint8 = 5
+)
+
+// A log level, describing a kind of message.
+type Level = uint8
+
+//go:wasmimport wasi:logging/logging log
+func wasm_import_log(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32)
+
+func Log(level Level, context string, message string) {
+	pinner := &runtime.Pinner{}
+	defer pinner.Unpin()
+
+	utf8 := unsafe.Pointer(unsafe.StringData(context))
+	pinner.Pin(utf8)
+	utf80 := unsafe.Pointer(unsafe.StringData(message))
+	pinner.Pin(utf80)
+	wasm_import_log(int32(level), uintptr(utf8), uint32(len(context)), uintptr(utf80), uint32(len(message)))
+
+}
diff --git a/sdks/go/golem/internal/wit/wit_exports/empty.s b/sdks/go/golem/internal/wit/wit_exports/empty.s
new file mode 100644
index 0000000000..308ab6016b
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wit_exports/empty.s
@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.
\ No newline at end of file
diff --git a/sdks/go/golem/internal/wit/wit_exports/wit_exports.go b/sdks/go/golem/internal/wit/wit_exports/wit_exports.go
new file mode 100644
index 0000000000..6eb2afada9
--- /dev/null
+++ b/sdks/go/golem/internal/wit/wit_exports/wit_exports.go
@@ -0,0 +1,19733 @@
+// Generated by `wit-bindgen` 0.58.0. DO NOT EDIT!
+//
+// This code was generated from the following packages:
+//     golem:core@2.0.0
+//     wasi:clocks@0.3.0
+//     golem:api@1.5.0
+//     golem:agent@2.0.0
+//     golem:rdbms@1.5.0
+//     golem:durability@1.5.0
+//     golem:quota@1.5.0
+//     golem:secrets@0.1.0
+//     wasi:filesystem@0.3.0
+//     wasi:sockets@0.3.0
+//     wasi:random@0.3.0
+//     wasi:cli@0.3.0
+//     wasi:blobstore
+//     wasi:keyvalue@0.1.0
+//     wasi:config@0.2.0-draft
+//     wasi:logging
+//     golem:websocket@1.5.0
+//     wasi:http@0.3.0
+//     golem:agent-guest
+//     golem:tool@0.1.0
+//     wasi:io@0.2.6
+//     wasi:clocks@0.2.6
+//     wasi:filesystem@0.2.6
+//     wasi:sockets@0.2.6
+//     wasi:random@0.2.6
+//     wasi:cli@0.2.6
+//     wasi:http@0.2.6
+
+package wit_exports
+
+import (
+	"github.com/golemcloud/golem/sdks/go/golem/internal/exports/export_golem_agent_guest"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/exports/export_golem_api_load_snapshot"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/exports/export_golem_api_save_snapshot"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_host"
+	"github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	witAsync "go.bytecodealliance.org/pkg/wit/async"
+	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+	"runtime"
+	"unsafe"
+)
+
+var staticPinner = runtime.Pinner{}
+var exportReturnArea = uintptr(witRuntime.Allocate(&staticPinner, (32 + 36*4), 8))
+var syncExportPinner = runtime.Pinner{}
+
+//go:wasmexport [async-lift]golem:api/save-snapshot@1.5.0#save
+func wasm_export_golem_api_save_snapshot_save() int32 {
+	return int32(witAsync.Run(func() {
+		pinner := &runtime.Pinner{}
+		defer pinner.Unpin()
+		result := export_golem_api_save_snapshot.Save()
+		data := unsafe.Pointer(unsafe.SliceData((result).Payload))
+		pinner.Pin(data)
+		utf8 := unsafe.Pointer(unsafe.StringData((result).MimeType))
+		pinner.Pin(utf8)
+		wasm_export_task_return_golem_api_save_snapshot_save(uintptr(data), uint32(len((result).Payload)), uintptr(utf8), uint32(len((result).MimeType)))
+
+	}))
+}
+
+//go:wasmexport [callback][async-lift]golem:api/save-snapshot@1.5.0#save
+func wasm_export_callback_golem_api_save_snapshot_save(event0 uint32, event1 uint32, event2 uint32) uint32 {
+	return witAsync.Callback(event0, event1, event2)
+}
+
+//go:wasmimport [export]golem:api/save-snapshot@1.5.0 [task-return]save
+func wasm_export_task_return_golem_api_save_snapshot_save(arg0 uintptr, arg1 uint32, arg2 uintptr, arg3 uint32)
+
+//go:wasmexport [async-lift]golem:api/load-snapshot@1.5.0#load
+func wasm_export_golem_api_load_snapshot_load(arg0 uintptr, arg1 uint32, arg2 uintptr, arg3 uint32) int32 {
+	return int32(witAsync.Run(func() {
+		pinner := &runtime.Pinner{}
+		defer pinner.Unpin()
+		value := unsafe.Slice((*uint8)(unsafe.Pointer(arg0)), arg1)
+		value0 := unsafe.String((*uint8)(unsafe.Pointer(arg2)), arg3)
+		witRuntime.Unpin()
+		result := export_golem_api_load_snapshot.Load(golem_api_host.Snapshot{value, value0})
+		var option int32
+		var option1 uintptr
+		var option2 uint32
+		switch result.Tag() {
+		case witTypes.ResultOk:
+
+			option = int32(0)
+			option1 = 0
+			option2 = 0
+		case witTypes.ResultErr:
+			payload := result.Err()
+			utf8 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8)
+
+			option = int32(1)
+			option1 = uintptr(utf8)
+			option2 = uint32(len(payload))
+		default:
+			panic("unreachable")
+		}
+		wasm_export_task_return_golem_api_load_snapshot_load(option, option1, option2)
+
+	}))
+}
+
+//go:wasmexport [callback][async-lift]golem:api/load-snapshot@1.5.0#load
+func wasm_export_callback_golem_api_load_snapshot_load(event0 uint32, event1 uint32, event2 uint32) uint32 {
+	return witAsync.Callback(event0, event1, event2)
+}
+
+//go:wasmimport [export]golem:api/load-snapshot@1.5.0 [task-return]load
+func wasm_export_task_return_golem_api_load_snapshot_load(arg0 int32, arg1 uintptr, arg2 uint32)
+
+//go:wasmexport [async-lift]golem:agent/guest@2.0.0#initialize
+func wasm_export_golem_agent_guest_initialize(arg0 uintptr) int32 {
+	return int32(witAsync.Run(func() {
+		pinner := &runtime.Pinner{}
+		defer pinner.Unpin()
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), 4)))
+		result20 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (3 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (3 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (2 * 4))))), index*(16+4*4))
+			var variant19 golem_core_types.SchemaValueNode
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+			case 1:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 2:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 3:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 4:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 5:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 6:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 7:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 8:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 9:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 10:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 11:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 12:
+				value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant19 = golem_core_types.MakeSchemaValueNodeStringValue(value0)
+
+			case 13:
+				result := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result = append(result, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeRecordValue(result)
+
+			case 14:
+				var option witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+				case 0:
+
+					option = witTypes.None[int32]()
+				case 1:
+
+					option = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+				default:
+					panic("unreachable")
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option})
+
+			case 15:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 16:
+				result1 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+					result1 = append(result1, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1)
+
+			case 17:
+				result2 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result2 = append(result2, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeTupleValue(result2)
+
+			case 18:
+				result3 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result3 = append(result3, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeListValue(result3)
+
+			case 19:
+				result4 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result4 = append(result4, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeFixedListValue(result4)
+
+			case 20:
+				result5 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+					result5 = append(result5, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeMapValue(result5)
+
+			case 21:
+				var option6 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option6 = witTypes.None[int32]()
+				case 1:
+
+					option6 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+				default:
+					panic("unreachable")
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeOptionValue(option6)
+
+			case 22:
+				var variant golem_core_types.ResultValuePayload
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+					var option7 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+					case 0:
+
+						option7 = witTypes.None[int32]()
+					case 1:
+
+						option7 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+					default:
+						panic("unreachable")
+					}
+
+					variant = golem_core_types.MakeResultValuePayloadOkValue(option7)
+
+				case 1:
+					var option8 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+					case 0:
+
+						option8 = witTypes.None[int32]()
+					case 1:
+
+						option8 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+					default:
+						panic("unreachable")
+					}
+
+					variant = golem_core_types.MakeResultValuePayloadErrValue(option8)
+
+				default:
+					panic("unreachable")
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeResultValue(variant)
+
+			case 23:
+				value9 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var option11 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+
+					option11 = witTypes.None[string]()
+				case 1:
+					value10 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+					option11 = witTypes.Some[string](value10)
+				default:
+					panic("unreachable")
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value9, option11})
+
+			case 24:
+				value12 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var option14 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+
+					option14 = witTypes.None[string]()
+				case 1:
+					value13 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+					option14 = witTypes.Some[string](value13)
+				default:
+					panic("unreachable")
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value12, option14})
+
+			case 25:
+				value15 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant19 = golem_core_types.MakeSchemaValueNodePathValue(value15)
+
+			case 26:
+				value16 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant19 = golem_core_types.MakeSchemaValueNodeUrlValue(value16)
+
+			case 27:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+			case 28:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+			case 29:
+				value17 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				variant19 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value17})
+
+			case 30:
+				value18 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant19 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value18, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+			case 31:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+			case 32:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+			default:
+				panic("unreachable")
+			}
+
+			result20 = append(result20, variant19)
+		}
+
+		var variant38 golem_agent_common.Principal
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (8 + 4*4)))) {
+		case 0:
+			value21 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 5*4))))
+			value22 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 6*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 7*4))))
+			var option24 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 8*4)))) {
+			case 0:
+
+				option24 = witTypes.None[string]()
+			case 1:
+				value23 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 10*4))))
+
+				option24 = witTypes.Some[string](value23)
+			default:
+				panic("unreachable")
+			}
+			var option26 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 11*4)))) {
+			case 0:
+
+				option26 = witTypes.None[string]()
+			case 1:
+				value25 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 12*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 13*4))))
+
+				option26 = witTypes.Some[string](value25)
+			default:
+				panic("unreachable")
+			}
+			var option27 witTypes.Option[bool]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 14*4)))) {
+			case 0:
+
+				option27 = witTypes.None[bool]()
+			case 1:
+
+				option27 = witTypes.Some[bool]((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (17 + 14*4)))) != 0))
+			default:
+				panic("unreachable")
+			}
+			var option29 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 15*4)))) {
+			case 0:
+
+				option29 = witTypes.None[string]()
+			case 1:
+				value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 17*4))))
+
+				option29 = witTypes.Some[string](value28)
+			default:
+				panic("unreachable")
+			}
+			var option31 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 18*4)))) {
+			case 0:
+
+				option31 = witTypes.None[string]()
+			case 1:
+				value30 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 19*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 20*4))))
+
+				option31 = witTypes.Some[string](value30)
+			default:
+				panic("unreachable")
+			}
+			var option33 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 21*4)))) {
+			case 0:
+
+				option33 = witTypes.None[string]()
+			case 1:
+				value32 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 22*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 23*4))))
+
+				option33 = witTypes.Some[string](value32)
+			default:
+				panic("unreachable")
+			}
+			var option35 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 24*4)))) {
+			case 0:
+
+				option35 = witTypes.None[string]()
+			case 1:
+				value34 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 25*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 26*4))))
+
+				option35 = witTypes.Some[string](value34)
+			default:
+				panic("unreachable")
+			}
+			value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 27*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 28*4))))
+
+			variant38 = golem_agent_common.MakePrincipalOidc(golem_agent_common.OidcPrincipal{value21, value22, option24, option26, option27, option29, option31, option33, option35, value36})
+
+		case 1:
+			value37 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (32 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (32 + 5*4))))
+
+			variant38 = golem_agent_common.MakePrincipalAgent(golem_agent_common.AgentPrincipal{golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(arg0), (16 + 4*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(arg0), (24 + 4*4))))}}, value37}})
+
+		case 2:
+
+			variant38 = golem_agent_common.MakePrincipalGolemUser(golem_agent_common.GolemUserPrincipal{golem_core_types.AccountId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(arg0), (16 + 4*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(arg0), (24 + 4*4))))}}})
+
+		case 3:
+
+			variant38 = golem_agent_common.MakePrincipalAnonymous()
+
+		default:
+			panic("unreachable")
+		}
+		witRuntime.Unpin()
+		result39 := export_golem_agent_guest.Initialize(value, golem_core_types.SchemaValueTree{result20, *(*int32)(unsafe.Add(unsafe.Pointer(arg0), (4 * 4)))}, variant38)
+		var option207 int32
+		var option208 int32
+		var option209 uintptr
+		var option210 uint32
+		var option211 uintptr
+		var option212 uint32
+		var option213 int32
+		var option214 uintptr
+		var option215 uint32
+		var option216 int32
+		switch result39.Tag() {
+		case witTypes.ResultOk:
+
+			option207 = int32(0)
+			option208 = 0
+			option209 = 0
+			option210 = 0
+			option211 = 0
+			option212 = 0
+			option213 = 0
+			option214 = 0
+			option215 = 0
+			option216 = 0
+		case witTypes.ResultErr:
+			payload := result39.Err()
+			var variant198 int32
+			var variant199 uintptr
+			var variant200 uint32
+			var variant201 uintptr
+			var variant202 uint32
+			var variant203 int32
+			var variant204 uintptr
+			var variant205 uint32
+			var variant206 int32
+			switch payload.Tag() {
+			case golem_agent_common.AgentErrorInvalidInput:
+				payload := payload.InvalidInput()
+				utf8 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8)
+
+				variant198 = int32(0)
+				variant199 = uintptr(utf8)
+				variant200 = uint32(len(payload))
+				variant201 = 0
+				variant202 = 0
+				variant203 = 0
+				variant204 = 0
+				variant205 = 0
+				variant206 = 0
+
+			case golem_agent_common.AgentErrorInvalidMethod:
+				payload := payload.InvalidMethod()
+				utf840 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf840)
+
+				variant198 = int32(1)
+				variant199 = uintptr(utf840)
+				variant200 = uint32(len(payload))
+				variant201 = 0
+				variant202 = 0
+				variant203 = 0
+				variant204 = 0
+				variant205 = 0
+				variant206 = 0
+
+			case golem_agent_common.AgentErrorInvalidType:
+				payload := payload.InvalidType()
+				utf841 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf841)
+
+				variant198 = int32(2)
+				variant199 = uintptr(utf841)
+				variant200 = uint32(len(payload))
+				variant201 = 0
+				variant202 = 0
+				variant203 = 0
+				variant204 = 0
+				variant205 = 0
+				variant206 = 0
+
+			case golem_agent_common.AgentErrorInvalidAgentId:
+				payload := payload.InvalidAgentId()
+				utf842 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf842)
+
+				variant198 = int32(3)
+				variant199 = uintptr(utf842)
+				variant200 = uint32(len(payload))
+				variant201 = 0
+				variant202 = 0
+				variant203 = 0
+				variant204 = 0
+				variant205 = 0
+				variant206 = 0
+
+			case golem_agent_common.AgentErrorCustomError:
+				payload := payload.CustomError()
+				slice159 := ((payload).Graph).TypeNodes
+				length161 := uint32(len(slice159))
+				result160 := witRuntime.Allocate(pinner, uintptr(length161*(56+22*4)), 8)
+				for index, element := range slice159 {
+					base := unsafe.Add(result160, index*(56+22*4))
+
+					switch (element).Body.Tag() {
+					case golem_core_types.SchemaTypeBodyRefType:
+						payload := (element).Body.RefType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaTypeBodyBoolType:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+					case golem_core_types.SchemaTypeBodyS8Type:
+						payload := (element).Body.S8Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf843 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf843)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf843)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyS16Type:
+						payload := (element).Body.S16Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf844 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf844)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf844)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyS32Type:
+						payload := (element).Body.S32Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf845 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf845)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf845)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyS64Type:
+						payload := (element).Body.S64Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf846 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf846)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf846)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyU8Type:
+						payload := (element).Body.U8Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf847 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf847)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf847)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyU16Type:
+						payload := (element).Body.U16Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf848 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf848)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf848)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyU32Type:
+						payload := (element).Body.U32Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf849 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf849)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf849)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyU64Type:
+						payload := (element).Body.U64Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf850 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf850)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf850)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyF32Type:
+						payload := (element).Body.F32Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf851 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf851)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf851)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyF64Type:
+						payload := (element).Body.F64Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf852 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf852)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf852)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyCharType:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+
+					case golem_core_types.SchemaTypeBodyStringType:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+
+					case golem_core_types.SchemaTypeBodyRecordType:
+						payload := (element).Body.RecordType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+						slice63 := payload
+						length65 := uint32(len(slice63))
+						result64 := witRuntime.Allocate(pinner, uintptr(length65*(17*4)), 4)
+						for index, element := range slice63 {
+							base := unsafe.Add(result64, index*(17*4))
+							utf853 := unsafe.Pointer(unsafe.StringData((element).Name))
+							pinner.Pin(utf853)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf853)))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+							switch ((element).Metadata).Doc.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Doc.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+								utf854 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf854)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf854)))
+
+							default:
+								panic("unreachable")
+							}
+							slice := ((element).Metadata).Aliases
+							length := uint32(len(slice))
+							result56 := witRuntime.Allocate(pinner, uintptr(length*(2*4)), 4)
+							for index, element := range slice {
+								base := unsafe.Add(result56, index*(2*4))
+								utf855 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf855)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf855)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result56)))
+							slice58 := ((element).Metadata).Examples
+							length60 := uint32(len(slice58))
+							result59 := witRuntime.Allocate(pinner, uintptr(length60*(2*4)), 4)
+							for index, element := range slice58 {
+								base := unsafe.Add(result59, index*(2*4))
+								utf857 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf857)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf857)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = uint32(length60)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result59)))
+
+							switch ((element).Metadata).Deprecated.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Deprecated.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(1))
+								utf861 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf861)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf861)))
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Role.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Role.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.RoleMultimodal:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(0))
+
+								case golem_core_types.RoleUnstructuredText:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(1))
+
+								case golem_core_types.RoleUnstructuredBinary:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(2))
+
+								case golem_core_types.RoleOther:
+									payload := payload.Other()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(3))
+									utf862 := unsafe.Pointer(unsafe.StringData(payload))
+									pinner.Pin(utf862)
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uint32(len(payload)))
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uintptr(uintptr(utf862)))
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length65)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result64)))
+
+					case golem_core_types.SchemaTypeBodyVariantType:
+						payload := (element).Body.VariantType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+						slice78 := payload
+						length80 := uint32(len(slice78))
+						result79 := witRuntime.Allocate(pinner, uintptr(length80*(8+16*4)), 4)
+						for index, element := range slice78 {
+							base := unsafe.Add(result79, index*(8+16*4))
+							utf866 := unsafe.Pointer(unsafe.StringData((element).Name))
+							pinner.Pin(utf866)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf866)))
+
+							switch (element).Payload.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (element).Payload.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+								*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = payload
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Doc.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Doc.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+								utf867 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf867)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf867)))
+
+							default:
+								panic("unreachable")
+							}
+							slice69 := ((element).Metadata).Aliases
+							length71 := uint32(len(slice69))
+							result70 := witRuntime.Allocate(pinner, uintptr(length71*(2*4)), 4)
+							for index, element := range slice69 {
+								base := unsafe.Add(result70, index*(2*4))
+								utf868 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf868)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf868)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length71)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result70)))
+							slice73 := ((element).Metadata).Examples
+							length75 := uint32(len(slice73))
+							result74 := witRuntime.Allocate(pinner, uintptr(length75*(2*4)), 4)
+							for index, element := range slice73 {
+								base := unsafe.Add(result74, index*(2*4))
+								utf872 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf872)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf872)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length75)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result74)))
+
+							switch ((element).Metadata).Deprecated.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Deprecated.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+								utf876 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf876)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf876)))
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Role.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Role.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.RoleMultimodal:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+								case golem_core_types.RoleUnstructuredText:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+								case golem_core_types.RoleUnstructuredBinary:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+								case golem_core_types.RoleOther:
+									payload := payload.Other()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+									utf877 := unsafe.Pointer(unsafe.StringData(payload))
+									pinner.Pin(utf877)
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf877)))
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length80)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result79)))
+
+					case golem_core_types.SchemaTypeBodyEnumType:
+						payload := (element).Body.EnumType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+						slice82 := payload
+						length84 := uint32(len(slice82))
+						result83 := witRuntime.Allocate(pinner, uintptr(length84*(2*4)), 4)
+						for index, element := range slice82 {
+							base := unsafe.Add(result83, index*(2*4))
+							utf881 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf881)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf881)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length84)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result83)))
+
+					case golem_core_types.SchemaTypeBodyFlagsType:
+						payload := (element).Body.FlagsType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+						slice86 := payload
+						length88 := uint32(len(slice86))
+						result87 := witRuntime.Allocate(pinner, uintptr(length88*(2*4)), 4)
+						for index, element := range slice86 {
+							base := unsafe.Add(result87, index*(2*4))
+							utf885 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf885)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf885)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length88)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result87)))
+
+					case golem_core_types.SchemaTypeBodyTupleType:
+						payload := (element).Body.TupleType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+						slice89 := payload
+						length91 := uint32(len(slice89))
+						result90 := witRuntime.Allocate(pinner, uintptr(length91*4), 4)
+						for index, element := range slice89 {
+							base := unsafe.Add(result90, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length91)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result90)))
+
+					case golem_core_types.SchemaTypeBodyListType:
+						payload := (element).Body.ListType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaTypeBodyFixedListType:
+						payload := (element).Body.FixedListType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Element
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Length)
+
+					case golem_core_types.SchemaTypeBodyMapType:
+						payload := (element).Body.MapType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Key
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Value
+
+					case golem_core_types.SchemaTypeBodyOptionType:
+						payload := (element).Body.OptionType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaTypeBodyResultType:
+						payload := (element).Body.ResultType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+						switch (payload).Ok.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Ok.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Err.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Err.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyTextType:
+						payload := (element).Body.TextType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+						switch (payload).Languages.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Languages.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							slice93 := payload
+							length95 := uint32(len(slice93))
+							result94 := witRuntime.Allocate(pinner, uintptr(length95*(2*4)), 4)
+							for index, element := range slice93 {
+								base := unsafe.Add(result94, index*(2*4))
+								utf892 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf892)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf892)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length95)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result94)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).MinLength.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MinLength.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).MaxLength.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MaxLength.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Regex.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Regex.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(1))
+							utf896 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf896)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = uint32(uintptr(uintptr(utf896)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyBinaryType:
+						payload := (element).Body.BinaryType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+
+						switch (payload).MimeTypes.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MimeTypes.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							slice98 := payload
+							length100 := uint32(len(slice98))
+							result99 := witRuntime.Allocate(pinner, uintptr(length100*(2*4)), 4)
+							for index, element := range slice98 {
+								base := unsafe.Add(result99, index*(2*4))
+								utf897 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf897)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf897)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length100)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result99)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).MinBytes.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MinBytes.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).MaxBytes.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MaxBytes.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyPathType:
+						payload := (element).Body.PathType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Direction))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Kind))
+
+						switch (payload).AllowedMimeTypes.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).AllowedMimeTypes.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+							slice102 := payload
+							length104 := uint32(len(slice102))
+							result103 := witRuntime.Allocate(pinner, uintptr(length104*(2*4)), 4)
+							for index, element := range slice102 {
+								base := unsafe.Add(result103, index*(2*4))
+								utf8101 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8101)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8101)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length104)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result103)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).AllowedExtensions.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).AllowedExtensions.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+							slice106 := payload
+							length108 := uint32(len(slice106))
+							result107 := witRuntime.Allocate(pinner, uintptr(length108*(2*4)), 4)
+							for index, element := range slice106 {
+								base := unsafe.Add(result107, index*(2*4))
+								utf8105 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8105)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8105)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length108)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result107)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyUrlType:
+						payload := (element).Body.UrlType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+
+						switch (payload).AllowedSchemes.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).AllowedSchemes.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							slice110 := payload
+							length112 := uint32(len(slice110))
+							result111 := witRuntime.Allocate(pinner, uintptr(length112*(2*4)), 4)
+							for index, element := range slice110 {
+								base := unsafe.Add(result111, index*(2*4))
+								utf8109 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8109)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8109)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length112)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result111)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).AllowedHosts.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).AllowedHosts.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+							slice114 := payload
+							length116 := uint32(len(slice114))
+							result115 := witRuntime.Allocate(pinner, uintptr(length116*(2*4)), 4)
+							for index, element := range slice114 {
+								base := unsafe.Add(result115, index*(2*4))
+								utf8113 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8113)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8113)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(length116)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(result115)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyDatetimeType:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+					case golem_core_types.SchemaTypeBodyDurationType:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+					case golem_core_types.SchemaTypeBodyQuantityType:
+						payload := (element).Body.QuantityType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+						utf8117 := unsafe.Pointer(unsafe.StringData((payload).BaseUnit))
+						pinner.Pin(utf8117)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).BaseUnit)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8117)))
+						slice119 := (payload).AllowedSuffixes
+						length121 := uint32(len(slice119))
+						result120 := witRuntime.Allocate(pinner, uintptr(length121*(2*4)), 4)
+						for index, element := range slice119 {
+							base := unsafe.Add(result120, index*(2*4))
+							utf8118 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8118)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8118)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length121)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result120)))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))) = (payload).Mantissa
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = (payload).Scale
+							utf8122 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+							pinner.Pin(utf8122)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))) = uint32(uint32(len((payload).Unit)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uintptr(uintptr(utf8122)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))) = (payload).Mantissa
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))) = (payload).Scale
+							utf8123 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+							pinner.Pin(utf8123)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))) = uint32(uint32(len((payload).Unit)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4))) = uint32(uintptr(uintptr(utf8123)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyUnionType:
+						payload := (element).Body.UnionType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+						slice143 := (payload).Branches
+						length145 := uint32(len(slice143))
+						result144 := witRuntime.Allocate(pinner, uintptr(length145*(23*4)), 4)
+						for index, element := range slice143 {
+							base := unsafe.Add(result144, index*(23*4))
+							utf8124 := unsafe.Pointer(unsafe.StringData((element).Tag))
+							pinner.Pin(utf8124)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Tag)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8124)))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+							switch (element).Discriminator.Tag() {
+							case golem_core_types.DiscriminatorRulePrefix:
+								payload := (element).Discriminator.Prefix()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+								utf8125 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8125)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8125)))
+
+							case golem_core_types.DiscriminatorRuleSuffix:
+								payload := (element).Discriminator.Suffix()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+								utf8126 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8126)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8126)))
+
+							case golem_core_types.DiscriminatorRuleContains:
+								payload := (element).Discriminator.Contains()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(2))
+								utf8127 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8127)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8127)))
+
+							case golem_core_types.DiscriminatorRuleRegex:
+								payload := (element).Discriminator.Regex()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(3))
+								utf8128 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8128)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8128)))
+
+							case golem_core_types.DiscriminatorRuleFieldEquals:
+								payload := (element).Discriminator.FieldEquals()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(4))
+								utf8129 := unsafe.Pointer(unsafe.StringData((payload).FieldName))
+								pinner.Pin(utf8129)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((payload).FieldName)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8129)))
+
+								switch (payload).Literal.Tag() {
+								case witTypes.OptionNone:
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+								case witTypes.OptionSome:
+									payload := (payload).Literal.Some()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+									utf8130 := unsafe.Pointer(unsafe.StringData(payload))
+									pinner.Pin(utf8130)
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8130)))
+
+								default:
+									panic("unreachable")
+								}
+
+							case golem_core_types.DiscriminatorRuleFieldAbsent:
+								payload := (element).Discriminator.FieldAbsent()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(5))
+								utf8131 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8131)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8131)))
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Doc.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Doc.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+								utf8132 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8132)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(utf8132)))
+
+							default:
+								panic("unreachable")
+							}
+							slice134 := ((element).Metadata).Aliases
+							length136 := uint32(len(slice134))
+							result135 := witRuntime.Allocate(pinner, uintptr(length136*(2*4)), 4)
+							for index, element := range slice134 {
+								base := unsafe.Add(result135, index*(2*4))
+								utf8133 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8133)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8133)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(length136)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(result135)))
+							slice138 := ((element).Metadata).Examples
+							length140 := uint32(len(slice138))
+							result139 := witRuntime.Allocate(pinner, uintptr(length140*(2*4)), 4)
+							for index, element := range slice138 {
+								base := unsafe.Add(result139, index*(2*4))
+								utf8137 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8137)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8137)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(length140)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(result139)))
+
+							switch ((element).Metadata).Deprecated.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Deprecated.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(1))
+								utf8141 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8141)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf8141)))
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Role.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Role.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.RoleMultimodal:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(0))
+
+								case golem_core_types.RoleUnstructuredText:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(1))
+
+								case golem_core_types.RoleUnstructuredBinary:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(2))
+
+								case golem_core_types.RoleOther:
+									payload := payload.Other()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(3))
+									utf8142 := unsafe.Pointer(unsafe.StringData(payload))
+									pinner.Pin(utf8142)
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uint32(len(payload)))
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(utf8142)))
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length145)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result144)))
+
+					case golem_core_types.SchemaTypeBodySecretType:
+						payload := (element).Body.SecretType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Inner
+
+						switch (payload).Category.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Category.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+							utf8146 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8146)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8146)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyQuotaTokenType:
+						payload := (element).Body.QuotaTokenType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+						switch (payload).ResourceName.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).ResourceName.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							utf8147 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8147)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf8147)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyFutureType:
+						payload := (element).Body.FutureType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyStreamType:
+						payload := (element).Body.StreamType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Doc.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Doc.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(1))
+						utf8148 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8148)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4))) = uint32(uintptr(uintptr(utf8148)))
+
+					default:
+						panic("unreachable")
+					}
+					slice150 := ((element).Metadata).Aliases
+					length152 := uint32(len(slice150))
+					result151 := witRuntime.Allocate(pinner, uintptr(length152*(2*4)), 4)
+					for index, element := range slice150 {
+						base := unsafe.Add(result151, index*(2*4))
+						utf8149 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8149)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8149)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length152)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result151)))
+					slice154 := ((element).Metadata).Examples
+					length156 := uint32(len(slice154))
+					result155 := witRuntime.Allocate(pinner, uintptr(length156*(2*4)), 4)
+					for index, element := range slice154 {
+						base := unsafe.Add(result155, index*(2*4))
+						utf8153 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8153)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8153)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length156)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result155)))
+
+					switch ((element).Metadata).Deprecated.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Deprecated.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(1))
+						utf8157 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8157)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4))) = uint32(uintptr(uintptr(utf8157)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Role.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Role.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.RoleMultimodal:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(0))
+
+						case golem_core_types.RoleUnstructuredText:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(1))
+
+						case golem_core_types.RoleUnstructuredBinary:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(2))
+
+						case golem_core_types.RoleOther:
+							payload := payload.Other()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(3))
+							utf8158 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8158)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4))) = uint32(uintptr(uintptr(utf8158)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				slice164 := ((payload).Graph).Defs
+				length166 := uint32(len(slice164))
+				result165 := witRuntime.Allocate(pinner, uintptr(length166*(6*4)), 4)
+				for index, element := range slice164 {
+					base := unsafe.Add(result165, index*(6*4))
+					utf8162 := unsafe.Pointer(unsafe.StringData((element).Id))
+					pinner.Pin(utf8162)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8162)))
+
+					switch (element).Name.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (element).Name.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+						utf8163 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8163)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8163)))
+
+					default:
+						panic("unreachable")
+					}
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body
+
+				}
+
+				slice195 := ((payload).Value).ValueNodes
+				length197 := uint32(len(slice195))
+				result196 := witRuntime.Allocate(pinner, uintptr(length197*(16+4*4)), 8)
+				for index, element := range slice195 {
+					base := unsafe.Add(result196, index*(16+4*4))
+
+					switch element.Tag() {
+					case golem_core_types.SchemaValueNodeBoolValue:
+						payload := element.BoolValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+						var result167 int32
+						if payload {
+							result167 = 1
+						} else {
+							result167 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result167)
+
+					case golem_core_types.SchemaValueNodeS8Value:
+						payload := element.S8Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+					case golem_core_types.SchemaValueNodeS16Value:
+						payload := element.S16Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+						*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+					case golem_core_types.SchemaValueNodeS32Value:
+						payload := element.S32Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeS64Value:
+						payload := element.S64Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeU8Value:
+						payload := element.U8Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+					case golem_core_types.SchemaValueNodeU16Value:
+						payload := element.U16Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+						*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+					case golem_core_types.SchemaValueNodeU32Value:
+						payload := element.U32Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+					case golem_core_types.SchemaValueNodeU64Value:
+						payload := element.U64Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+					case golem_core_types.SchemaValueNodeF32Value:
+						payload := element.F32Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+						*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeF64Value:
+						payload := element.F64Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+						*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeCharValue:
+						payload := element.CharValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+					case golem_core_types.SchemaValueNodeStringValue:
+						payload := element.StringValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+						utf8168 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8168)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8168)))
+
+					case golem_core_types.SchemaValueNodeRecordValue:
+						payload := element.RecordValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+						slice169 := payload
+						length171 := uint32(len(slice169))
+						result170 := witRuntime.Allocate(pinner, uintptr(length171*4), 4)
+						for index, element := range slice169 {
+							base := unsafe.Add(result170, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length171)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result170)))
+
+					case golem_core_types.SchemaValueNodeVariantValue:
+						payload := element.VariantValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).Case)
+
+						switch (payload).Payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeEnumValue:
+						payload := element.EnumValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+					case golem_core_types.SchemaValueNodeFlagsValue:
+						payload := element.FlagsValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+						slice173 := payload
+						length175 := uint32(len(slice173))
+						result174 := witRuntime.Allocate(pinner, uintptr(length175*1), 1)
+						for index, element := range slice173 {
+							base := unsafe.Add(result174, index*1)
+							var result172 int32
+							if element {
+								result172 = 1
+							} else {
+								result172 = 0
+							}
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result172)
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length175)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result174)))
+
+					case golem_core_types.SchemaValueNodeTupleValue:
+						payload := element.TupleValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+						slice176 := payload
+						length178 := uint32(len(slice176))
+						result177 := witRuntime.Allocate(pinner, uintptr(length178*4), 4)
+						for index, element := range slice176 {
+							base := unsafe.Add(result177, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length178)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result177)))
+
+					case golem_core_types.SchemaValueNodeListValue:
+						payload := element.ListValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+						slice179 := payload
+						length181 := uint32(len(slice179))
+						result180 := witRuntime.Allocate(pinner, uintptr(length181*4), 4)
+						for index, element := range slice179 {
+							base := unsafe.Add(result180, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length181)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result180)))
+
+					case golem_core_types.SchemaValueNodeFixedListValue:
+						payload := element.FixedListValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+						slice182 := payload
+						length184 := uint32(len(slice182))
+						result183 := witRuntime.Allocate(pinner, uintptr(length184*4), 4)
+						for index, element := range slice182 {
+							base := unsafe.Add(result183, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length184)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result183)))
+
+					case golem_core_types.SchemaValueNodeMapValue:
+						payload := element.MapValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+						slice185 := payload
+						length187 := uint32(len(slice185))
+						result186 := witRuntime.Allocate(pinner, uintptr(length187*8), 4)
+						for index, element := range slice185 {
+							base := unsafe.Add(result186, index*8)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).Key
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (element).Value
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length187)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result186)))
+
+					case golem_core_types.SchemaValueNodeOptionValue:
+						payload := element.OptionValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeResultValue:
+						payload := element.ResultValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+
+						switch payload.Tag() {
+						case golem_core_types.ResultValuePayloadOkValue:
+							payload := payload.OkValue()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+							switch payload.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := payload.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+								*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+							default:
+								panic("unreachable")
+							}
+
+						case golem_core_types.ResultValuePayloadErrValue:
+							payload := payload.ErrValue()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := payload.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+								*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeTextValue:
+						payload := element.TextValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+						utf8188 := unsafe.Pointer(unsafe.StringData((payload).Text))
+						pinner.Pin(utf8188)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8188)))
+
+						switch (payload).Language.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Language.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+							utf8189 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8189)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8189)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeBinaryValue:
+						payload := element.BinaryValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+						data := unsafe.Pointer(unsafe.SliceData((payload).Bytes))
+						pinner.Pin(data)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+						switch (payload).MimeType.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MimeType.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+							utf8190 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8190)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8190)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodePathValue:
+						payload := element.PathValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+						utf8191 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8191)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8191)))
+
+					case golem_core_types.SchemaValueNodeUrlValue:
+						payload := element.UrlValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+						utf8192 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8192)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8192)))
+
+					case golem_core_types.SchemaValueNodeDatetimeValue:
+						payload := element.DatetimeValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Seconds
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = int32((payload).Nanoseconds)
+
+					case golem_core_types.SchemaValueNodeDurationValue:
+						payload := element.DurationValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Nanoseconds
+
+					case golem_core_types.SchemaValueNodeQuantityValueNode:
+						payload := element.QuantityValueNode()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Mantissa
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Scale
+						utf8193 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+						pinner.Pin(utf8193)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uint32(len((payload).Unit)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))) = uint32(uintptr(uintptr(utf8193)))
+
+					case golem_core_types.SchemaValueNodeUnionValue:
+						payload := element.UnionValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+						utf8194 := unsafe.Pointer(unsafe.StringData((payload).Tag))
+						pinner.Pin(utf8194)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8194)))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Body
+
+					case golem_core_types.SchemaValueNodeSecretValue:
+						payload := element.SecretValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+					case golem_core_types.SchemaValueNodeQuotaTokenHandle:
+						payload := element.QuotaTokenHandle()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				variant198 = int32(4)
+				variant199 = uintptr(result160)
+				variant200 = length161
+				variant201 = uintptr(result165)
+				variant202 = length166
+				variant203 = ((payload).Graph).Root
+				variant204 = uintptr(result196)
+				variant205 = length197
+				variant206 = ((payload).Value).Root
+
+			default:
+				panic("unreachable")
+			}
+
+			option207 = int32(1)
+			option208 = variant198
+			option209 = variant199
+			option210 = variant200
+			option211 = variant201
+			option212 = variant202
+			option213 = variant203
+			option214 = variant204
+			option215 = variant205
+			option216 = variant206
+		default:
+			panic("unreachable")
+		}
+		wasm_export_task_return_golem_agent_guest_initialize(option207, option208, option209, option210, option211, option212, option213, option214, option215, option216)
+
+	}))
+}
+
+//go:wasmexport [callback][async-lift]golem:agent/guest@2.0.0#initialize
+func wasm_export_callback_golem_agent_guest_initialize(event0 uint32, event1 uint32, event2 uint32) uint32 {
+	return witAsync.Callback(event0, event1, event2)
+}
+
+//go:wasmimport [export]golem:agent/guest@2.0.0 [task-return]initialize
+func wasm_export_task_return_golem_agent_guest_initialize(arg0 int32, arg1 int32, arg2 uintptr, arg3 uint32, arg4 uintptr, arg5 uint32, arg6 int32, arg7 uintptr, arg8 uint32, arg9 int32)
+
+//go:wasmexport [async-lift]golem:agent/guest@2.0.0#invoke
+func wasm_export_golem_agent_guest_invoke(arg0 uintptr) int32 {
+	return int32(witAsync.Run(func() {
+		pinner := &runtime.Pinner{}
+		defer pinner.Unpin()
+		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), 4)))
+		result20 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (3 * 4))))
+		for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (3 * 4)))); index++ {
+			base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (2 * 4))))), index*(16+4*4))
+			var variant19 golem_core_types.SchemaValueNode
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) {
+			case 0:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0))
+
+			case 1:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 2:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 3:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 4:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 5:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 6:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))))
+
+			case 7:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 8:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 9:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 10:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)))
+
+			case 11:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 12:
+				value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant19 = golem_core_types.MakeSchemaValueNodeStringValue(value0)
+
+			case 13:
+				result := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result = append(result, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeRecordValue(result)
+
+			case 14:
+				var option witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+				case 0:
+
+					option = witTypes.None[int32]()
+				case 1:
+
+					option = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+				default:
+					panic("unreachable")
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option})
+
+			case 15:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))
+
+			case 16:
+				result1 := make([]bool, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*1)
+
+					result1 = append(result1, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0))
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1)
+
+			case 17:
+				result2 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result2 = append(result2, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeTupleValue(result2)
+
+			case 18:
+				result3 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result3 = append(result3, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeListValue(result3)
+
+			case 19:
+				result4 := make([]int32, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*4)
+
+					result4 = append(result4, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)))
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeFixedListValue(result4)
+
+			case 20:
+				result5 := make([]golem_core_types.MapEntry, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))); index++ {
+					base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)))), index*8)
+
+					result5 = append(result5, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))})
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeMapValue(result5)
+
+			case 21:
+				var option6 witTypes.Option[int32]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+
+					option6 = witTypes.None[int32]()
+				case 1:
+
+					option6 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)))
+				default:
+					panic("unreachable")
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeOptionValue(option6)
+
+			case 22:
+				var variant golem_core_types.ResultValuePayload
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) {
+				case 0:
+					var option7 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+					case 0:
+
+						option7 = witTypes.None[int32]()
+					case 1:
+
+						option7 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+					default:
+						panic("unreachable")
+					}
+
+					variant = golem_core_types.MakeResultValuePayloadOkValue(option7)
+
+				case 1:
+					var option8 witTypes.Option[int32]
+					switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) {
+					case 0:
+
+						option8 = witTypes.None[int32]()
+					case 1:
+
+						option8 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))
+					default:
+						panic("unreachable")
+					}
+
+					variant = golem_core_types.MakeResultValuePayloadErrValue(option8)
+
+				default:
+					panic("unreachable")
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeResultValue(variant)
+
+			case 23:
+				value9 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var option11 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+
+					option11 = witTypes.None[string]()
+				case 1:
+					value10 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+					option11 = witTypes.Some[string](value10)
+				default:
+					panic("unreachable")
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value9, option11})
+
+			case 24:
+				value12 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+				var option14 witTypes.Option[string]
+				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) {
+				case 0:
+
+					option14 = witTypes.None[string]()
+				case 1:
+					value13 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))))
+
+					option14 = witTypes.Some[string](value13)
+				default:
+					panic("unreachable")
+				}
+
+				variant19 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value12, option14})
+
+			case 25:
+				value15 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant19 = golem_core_types.MakeSchemaValueNodePathValue(value15)
+
+			case 26:
+				value16 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant19 = golem_core_types.MakeSchemaValueNodeUrlValue(value16)
+
+			case 27:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeDatetimeValue(golem_core_types.Datetime{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)))})
+
+			case 28:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))})
+
+			case 29:
+				value17 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))))
+
+				variant19 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value17})
+
+			case 30:
+				value18 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))))
+
+				variant19 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value18, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))})
+
+			case 31:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+			case 32:
+
+				variant19 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))))))
+
+			default:
+				panic("unreachable")
+			}
+
+			result20 = append(result20, variant19)
+		}
+
+		var variant38 golem_agent_common.Principal
+		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (8 + 4*4)))) {
+		case 0:
+			value21 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 5*4))))
+			value22 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 6*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 7*4))))
+			var option24 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 8*4)))) {
+			case 0:
+
+				option24 = witTypes.None[string]()
+			case 1:
+				value23 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 10*4))))
+
+				option24 = witTypes.Some[string](value23)
+			default:
+				panic("unreachable")
+			}
+			var option26 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 11*4)))) {
+			case 0:
+
+				option26 = witTypes.None[string]()
+			case 1:
+				value25 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 12*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 13*4))))
+
+				option26 = witTypes.Some[string](value25)
+			default:
+				panic("unreachable")
+			}
+			var option27 witTypes.Option[bool]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 14*4)))) {
+			case 0:
+
+				option27 = witTypes.None[bool]()
+			case 1:
+
+				option27 = witTypes.Some[bool]((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (17 + 14*4)))) != 0))
+			default:
+				panic("unreachable")
+			}
+			var option29 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 15*4)))) {
+			case 0:
+
+				option29 = witTypes.None[string]()
+			case 1:
+				value28 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 17*4))))
+
+				option29 = witTypes.Some[string](value28)
+			default:
+				panic("unreachable")
+			}
+			var option31 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 18*4)))) {
+			case 0:
+
+				option31 = witTypes.None[string]()
+			case 1:
+				value30 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 19*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 20*4))))
+
+				option31 = witTypes.Some[string](value30)
+			default:
+				panic("unreachable")
+			}
+			var option33 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 21*4)))) {
+			case 0:
+
+				option33 = witTypes.None[string]()
+			case 1:
+				value32 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 22*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 23*4))))
+
+				option33 = witTypes.Some[string](value32)
+			default:
+				panic("unreachable")
+			}
+			var option35 witTypes.Option[string]
+			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 24*4)))) {
+			case 0:
+
+				option35 = witTypes.None[string]()
+			case 1:
+				value34 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 25*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 26*4))))
+
+				option35 = witTypes.Some[string](value34)
+			default:
+				panic("unreachable")
+			}
+			value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 27*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (16 + 28*4))))
+
+			variant38 = golem_agent_common.MakePrincipalOidc(golem_agent_common.OidcPrincipal{value21, value22, option24, option26, option27, option29, option31, option33, option35, value36})
+
+		case 1:
+			value37 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (32 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(arg0), (32 + 5*4))))
+
+			variant38 = golem_agent_common.MakePrincipalAgent(golem_agent_common.AgentPrincipal{golem_core_types.AgentId{golem_core_types.ComponentId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(arg0), (16 + 4*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(arg0), (24 + 4*4))))}}, value37}})
+
+		case 2:
+
+			variant38 = golem_agent_common.MakePrincipalGolemUser(golem_agent_common.GolemUserPrincipal{golem_core_types.AccountId{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(arg0), (16 + 4*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(arg0), (24 + 4*4))))}}})
+
+		case 3:
+
+			variant38 = golem_agent_common.MakePrincipalAnonymous()
+
+		default:
+			panic("unreachable")
+		}
+		witRuntime.Unpin()
+		result39 := export_golem_agent_guest.Invoke(value, golem_core_types.SchemaValueTree{result20, *(*int32)(unsafe.Add(unsafe.Pointer(arg0), (4 * 4)))}, variant38)
+		var option243 int32
+		var option244 int32
+		var option245 uintptr
+		var option246 uint32
+		var option247 uintptr
+		var option248 uint32
+		var option249 int32
+		var option250 uintptr
+		var option251 uint32
+		var option252 int32
+		switch result39.Tag() {
+		case witTypes.ResultOk:
+			payload := result39.Ok()
+			var option68 int32
+			var option69 uintptr
+			var option70 uint32
+			var option71 int32
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+
+				option68 = int32(0)
+				option69 = 0
+				option70 = 0
+				option71 = 0
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				slice65 := (payload).ValueNodes
+				length67 := uint32(len(slice65))
+				result66 := witRuntime.Allocate(pinner, uintptr(length67*(16+4*4)), 8)
+				for index, element := range slice65 {
+					base := unsafe.Add(result66, index*(16+4*4))
+
+					switch element.Tag() {
+					case golem_core_types.SchemaValueNodeBoolValue:
+						payload := element.BoolValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+						var result40 int32
+						if payload {
+							result40 = 1
+						} else {
+							result40 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result40)
+
+					case golem_core_types.SchemaValueNodeS8Value:
+						payload := element.S8Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+					case golem_core_types.SchemaValueNodeS16Value:
+						payload := element.S16Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+						*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+					case golem_core_types.SchemaValueNodeS32Value:
+						payload := element.S32Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeS64Value:
+						payload := element.S64Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeU8Value:
+						payload := element.U8Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+					case golem_core_types.SchemaValueNodeU16Value:
+						payload := element.U16Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+						*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+					case golem_core_types.SchemaValueNodeU32Value:
+						payload := element.U32Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+					case golem_core_types.SchemaValueNodeU64Value:
+						payload := element.U64Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+					case golem_core_types.SchemaValueNodeF32Value:
+						payload := element.F32Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+						*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeF64Value:
+						payload := element.F64Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+						*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeCharValue:
+						payload := element.CharValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+					case golem_core_types.SchemaValueNodeStringValue:
+						payload := element.StringValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+						utf8 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8)))
+
+					case golem_core_types.SchemaValueNodeRecordValue:
+						payload := element.RecordValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+						slice := payload
+						length := uint32(len(slice))
+						result41 := witRuntime.Allocate(pinner, uintptr(length*4), 4)
+						for index, element := range slice {
+							base := unsafe.Add(result41, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result41)))
+
+					case golem_core_types.SchemaValueNodeVariantValue:
+						payload := element.VariantValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).Case)
+
+						switch (payload).Payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeEnumValue:
+						payload := element.EnumValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+					case golem_core_types.SchemaValueNodeFlagsValue:
+						payload := element.FlagsValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+						slice43 := payload
+						length45 := uint32(len(slice43))
+						result44 := witRuntime.Allocate(pinner, uintptr(length45*1), 1)
+						for index, element := range slice43 {
+							base := unsafe.Add(result44, index*1)
+							var result42 int32
+							if element {
+								result42 = 1
+							} else {
+								result42 = 0
+							}
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result42)
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length45)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result44)))
+
+					case golem_core_types.SchemaValueNodeTupleValue:
+						payload := element.TupleValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+						slice46 := payload
+						length48 := uint32(len(slice46))
+						result47 := witRuntime.Allocate(pinner, uintptr(length48*4), 4)
+						for index, element := range slice46 {
+							base := unsafe.Add(result47, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length48)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result47)))
+
+					case golem_core_types.SchemaValueNodeListValue:
+						payload := element.ListValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+						slice49 := payload
+						length51 := uint32(len(slice49))
+						result50 := witRuntime.Allocate(pinner, uintptr(length51*4), 4)
+						for index, element := range slice49 {
+							base := unsafe.Add(result50, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length51)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result50)))
+
+					case golem_core_types.SchemaValueNodeFixedListValue:
+						payload := element.FixedListValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+						slice52 := payload
+						length54 := uint32(len(slice52))
+						result53 := witRuntime.Allocate(pinner, uintptr(length54*4), 4)
+						for index, element := range slice52 {
+							base := unsafe.Add(result53, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length54)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result53)))
+
+					case golem_core_types.SchemaValueNodeMapValue:
+						payload := element.MapValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+						slice55 := payload
+						length57 := uint32(len(slice55))
+						result56 := witRuntime.Allocate(pinner, uintptr(length57*8), 4)
+						for index, element := range slice55 {
+							base := unsafe.Add(result56, index*8)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).Key
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (element).Value
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length57)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result56)))
+
+					case golem_core_types.SchemaValueNodeOptionValue:
+						payload := element.OptionValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeResultValue:
+						payload := element.ResultValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+
+						switch payload.Tag() {
+						case golem_core_types.ResultValuePayloadOkValue:
+							payload := payload.OkValue()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+							switch payload.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := payload.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+								*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+							default:
+								panic("unreachable")
+							}
+
+						case golem_core_types.ResultValuePayloadErrValue:
+							payload := payload.ErrValue()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := payload.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+								*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeTextValue:
+						payload := element.TextValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+						utf858 := unsafe.Pointer(unsafe.StringData((payload).Text))
+						pinner.Pin(utf858)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf858)))
+
+						switch (payload).Language.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Language.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+							utf859 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf859)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf859)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeBinaryValue:
+						payload := element.BinaryValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+						data := unsafe.Pointer(unsafe.SliceData((payload).Bytes))
+						pinner.Pin(data)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+						switch (payload).MimeType.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MimeType.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+							utf860 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf860)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf860)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodePathValue:
+						payload := element.PathValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+						utf861 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf861)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf861)))
+
+					case golem_core_types.SchemaValueNodeUrlValue:
+						payload := element.UrlValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+						utf862 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf862)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf862)))
+
+					case golem_core_types.SchemaValueNodeDatetimeValue:
+						payload := element.DatetimeValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Seconds
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = int32((payload).Nanoseconds)
+
+					case golem_core_types.SchemaValueNodeDurationValue:
+						payload := element.DurationValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Nanoseconds
+
+					case golem_core_types.SchemaValueNodeQuantityValueNode:
+						payload := element.QuantityValueNode()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Mantissa
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Scale
+						utf863 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+						pinner.Pin(utf863)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uint32(len((payload).Unit)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))) = uint32(uintptr(uintptr(utf863)))
+
+					case golem_core_types.SchemaValueNodeUnionValue:
+						payload := element.UnionValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+						utf864 := unsafe.Pointer(unsafe.StringData((payload).Tag))
+						pinner.Pin(utf864)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf864)))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Body
+
+					case golem_core_types.SchemaValueNodeSecretValue:
+						payload := element.SecretValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+					case golem_core_types.SchemaValueNodeQuotaTokenHandle:
+						payload := element.QuotaTokenHandle()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				option68 = int32(1)
+				option69 = uintptr(result66)
+				option70 = length67
+				option71 = (payload).Root
+			default:
+				panic("unreachable")
+			}
+
+			option243 = int32(0)
+			option244 = option68
+			option245 = option69
+			option246 = option70
+			option247 = uintptr(option71)
+			option248 = 0
+			option249 = 0
+			option250 = 0
+			option251 = 0
+			option252 = 0
+		case witTypes.ResultErr:
+			payload := result39.Err()
+			var variant234 int32
+			var variant235 uintptr
+			var variant236 uint32
+			var variant237 uintptr
+			var variant238 uint32
+			var variant239 int32
+			var variant240 uintptr
+			var variant241 uint32
+			var variant242 int32
+			switch payload.Tag() {
+			case golem_agent_common.AgentErrorInvalidInput:
+				payload := payload.InvalidInput()
+				utf872 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf872)
+
+				variant234 = int32(0)
+				variant235 = uintptr(utf872)
+				variant236 = uint32(len(payload))
+				variant237 = 0
+				variant238 = 0
+				variant239 = 0
+				variant240 = 0
+				variant241 = 0
+				variant242 = 0
+
+			case golem_agent_common.AgentErrorInvalidMethod:
+				payload := payload.InvalidMethod()
+				utf873 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf873)
+
+				variant234 = int32(1)
+				variant235 = uintptr(utf873)
+				variant236 = uint32(len(payload))
+				variant237 = 0
+				variant238 = 0
+				variant239 = 0
+				variant240 = 0
+				variant241 = 0
+				variant242 = 0
+
+			case golem_agent_common.AgentErrorInvalidType:
+				payload := payload.InvalidType()
+				utf874 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf874)
+
+				variant234 = int32(2)
+				variant235 = uintptr(utf874)
+				variant236 = uint32(len(payload))
+				variant237 = 0
+				variant238 = 0
+				variant239 = 0
+				variant240 = 0
+				variant241 = 0
+				variant242 = 0
+
+			case golem_agent_common.AgentErrorInvalidAgentId:
+				payload := payload.InvalidAgentId()
+				utf875 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf875)
+
+				variant234 = int32(3)
+				variant235 = uintptr(utf875)
+				variant236 = uint32(len(payload))
+				variant237 = 0
+				variant238 = 0
+				variant239 = 0
+				variant240 = 0
+				variant241 = 0
+				variant242 = 0
+
+			case golem_agent_common.AgentErrorCustomError:
+				payload := payload.CustomError()
+				slice194 := ((payload).Graph).TypeNodes
+				length196 := uint32(len(slice194))
+				result195 := witRuntime.Allocate(pinner, uintptr(length196*(56+22*4)), 8)
+				for index, element := range slice194 {
+					base := unsafe.Add(result195, index*(56+22*4))
+
+					switch (element).Body.Tag() {
+					case golem_core_types.SchemaTypeBodyRefType:
+						payload := (element).Body.RefType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaTypeBodyBoolType:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+					case golem_core_types.SchemaTypeBodyS8Type:
+						payload := (element).Body.S8Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf876 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf876)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf876)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyS16Type:
+						payload := (element).Body.S16Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf877 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf877)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf877)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyS32Type:
+						payload := (element).Body.S32Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf878 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf878)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf878)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyS64Type:
+						payload := (element).Body.S64Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf879 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf879)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf879)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyU8Type:
+						payload := (element).Body.U8Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf880 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf880)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf880)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyU16Type:
+						payload := (element).Body.U16Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf881 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf881)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf881)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyU32Type:
+						payload := (element).Body.U32Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf882 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf882)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf882)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyU64Type:
+						payload := (element).Body.U64Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf883 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf883)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf883)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyF32Type:
+						payload := (element).Body.F32Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf884 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf884)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf884)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyF64Type:
+						payload := (element).Body.F64Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf885 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf885)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf885)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyCharType:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+
+					case golem_core_types.SchemaTypeBodyStringType:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+
+					case golem_core_types.SchemaTypeBodyRecordType:
+						payload := (element).Body.RecordType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+						slice98 := payload
+						length100 := uint32(len(slice98))
+						result99 := witRuntime.Allocate(pinner, uintptr(length100*(17*4)), 4)
+						for index, element := range slice98 {
+							base := unsafe.Add(result99, index*(17*4))
+							utf886 := unsafe.Pointer(unsafe.StringData((element).Name))
+							pinner.Pin(utf886)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf886)))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+							switch ((element).Metadata).Doc.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Doc.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+								utf887 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf887)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf887)))
+
+							default:
+								panic("unreachable")
+							}
+							slice89 := ((element).Metadata).Aliases
+							length91 := uint32(len(slice89))
+							result90 := witRuntime.Allocate(pinner, uintptr(length91*(2*4)), 4)
+							for index, element := range slice89 {
+								base := unsafe.Add(result90, index*(2*4))
+								utf888 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf888)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf888)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length91)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result90)))
+							slice93 := ((element).Metadata).Examples
+							length95 := uint32(len(slice93))
+							result94 := witRuntime.Allocate(pinner, uintptr(length95*(2*4)), 4)
+							for index, element := range slice93 {
+								base := unsafe.Add(result94, index*(2*4))
+								utf892 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf892)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf892)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = uint32(length95)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result94)))
+
+							switch ((element).Metadata).Deprecated.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Deprecated.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(1))
+								utf896 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf896)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf896)))
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Role.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Role.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.RoleMultimodal:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(0))
+
+								case golem_core_types.RoleUnstructuredText:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(1))
+
+								case golem_core_types.RoleUnstructuredBinary:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(2))
+
+								case golem_core_types.RoleOther:
+									payload := payload.Other()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(3))
+									utf897 := unsafe.Pointer(unsafe.StringData(payload))
+									pinner.Pin(utf897)
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uint32(len(payload)))
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uintptr(uintptr(utf897)))
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length100)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result99)))
+
+					case golem_core_types.SchemaTypeBodyVariantType:
+						payload := (element).Body.VariantType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+						slice113 := payload
+						length115 := uint32(len(slice113))
+						result114 := witRuntime.Allocate(pinner, uintptr(length115*(8+16*4)), 4)
+						for index, element := range slice113 {
+							base := unsafe.Add(result114, index*(8+16*4))
+							utf8101 := unsafe.Pointer(unsafe.StringData((element).Name))
+							pinner.Pin(utf8101)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8101)))
+
+							switch (element).Payload.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (element).Payload.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+								*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = payload
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Doc.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Doc.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+								utf8102 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8102)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8102)))
+
+							default:
+								panic("unreachable")
+							}
+							slice104 := ((element).Metadata).Aliases
+							length106 := uint32(len(slice104))
+							result105 := witRuntime.Allocate(pinner, uintptr(length106*(2*4)), 4)
+							for index, element := range slice104 {
+								base := unsafe.Add(result105, index*(2*4))
+								utf8103 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8103)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8103)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length106)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result105)))
+							slice108 := ((element).Metadata).Examples
+							length110 := uint32(len(slice108))
+							result109 := witRuntime.Allocate(pinner, uintptr(length110*(2*4)), 4)
+							for index, element := range slice108 {
+								base := unsafe.Add(result109, index*(2*4))
+								utf8107 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8107)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8107)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length110)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result109)))
+
+							switch ((element).Metadata).Deprecated.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Deprecated.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+								utf8111 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8111)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf8111)))
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Role.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Role.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.RoleMultimodal:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+								case golem_core_types.RoleUnstructuredText:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+								case golem_core_types.RoleUnstructuredBinary:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+								case golem_core_types.RoleOther:
+									payload := payload.Other()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+									utf8112 := unsafe.Pointer(unsafe.StringData(payload))
+									pinner.Pin(utf8112)
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf8112)))
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length115)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result114)))
+
+					case golem_core_types.SchemaTypeBodyEnumType:
+						payload := (element).Body.EnumType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+						slice117 := payload
+						length119 := uint32(len(slice117))
+						result118 := witRuntime.Allocate(pinner, uintptr(length119*(2*4)), 4)
+						for index, element := range slice117 {
+							base := unsafe.Add(result118, index*(2*4))
+							utf8116 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8116)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8116)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length119)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result118)))
+
+					case golem_core_types.SchemaTypeBodyFlagsType:
+						payload := (element).Body.FlagsType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+						slice121 := payload
+						length123 := uint32(len(slice121))
+						result122 := witRuntime.Allocate(pinner, uintptr(length123*(2*4)), 4)
+						for index, element := range slice121 {
+							base := unsafe.Add(result122, index*(2*4))
+							utf8120 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8120)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8120)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length123)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result122)))
+
+					case golem_core_types.SchemaTypeBodyTupleType:
+						payload := (element).Body.TupleType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+						slice124 := payload
+						length126 := uint32(len(slice124))
+						result125 := witRuntime.Allocate(pinner, uintptr(length126*4), 4)
+						for index, element := range slice124 {
+							base := unsafe.Add(result125, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length126)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result125)))
+
+					case golem_core_types.SchemaTypeBodyListType:
+						payload := (element).Body.ListType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaTypeBodyFixedListType:
+						payload := (element).Body.FixedListType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Element
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Length)
+
+					case golem_core_types.SchemaTypeBodyMapType:
+						payload := (element).Body.MapType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Key
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Value
+
+					case golem_core_types.SchemaTypeBodyOptionType:
+						payload := (element).Body.OptionType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaTypeBodyResultType:
+						payload := (element).Body.ResultType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+						switch (payload).Ok.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Ok.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Err.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Err.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyTextType:
+						payload := (element).Body.TextType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+						switch (payload).Languages.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Languages.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							slice128 := payload
+							length130 := uint32(len(slice128))
+							result129 := witRuntime.Allocate(pinner, uintptr(length130*(2*4)), 4)
+							for index, element := range slice128 {
+								base := unsafe.Add(result129, index*(2*4))
+								utf8127 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8127)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8127)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length130)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result129)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).MinLength.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MinLength.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).MaxLength.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MaxLength.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Regex.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Regex.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(1))
+							utf8131 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8131)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = uint32(uintptr(uintptr(utf8131)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyBinaryType:
+						payload := (element).Body.BinaryType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+
+						switch (payload).MimeTypes.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MimeTypes.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							slice133 := payload
+							length135 := uint32(len(slice133))
+							result134 := witRuntime.Allocate(pinner, uintptr(length135*(2*4)), 4)
+							for index, element := range slice133 {
+								base := unsafe.Add(result134, index*(2*4))
+								utf8132 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8132)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8132)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length135)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result134)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).MinBytes.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MinBytes.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).MaxBytes.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MaxBytes.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyPathType:
+						payload := (element).Body.PathType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Direction))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Kind))
+
+						switch (payload).AllowedMimeTypes.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).AllowedMimeTypes.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+							slice137 := payload
+							length139 := uint32(len(slice137))
+							result138 := witRuntime.Allocate(pinner, uintptr(length139*(2*4)), 4)
+							for index, element := range slice137 {
+								base := unsafe.Add(result138, index*(2*4))
+								utf8136 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8136)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8136)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length139)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result138)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).AllowedExtensions.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).AllowedExtensions.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+							slice141 := payload
+							length143 := uint32(len(slice141))
+							result142 := witRuntime.Allocate(pinner, uintptr(length143*(2*4)), 4)
+							for index, element := range slice141 {
+								base := unsafe.Add(result142, index*(2*4))
+								utf8140 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8140)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8140)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length143)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result142)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyUrlType:
+						payload := (element).Body.UrlType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+
+						switch (payload).AllowedSchemes.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).AllowedSchemes.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							slice145 := payload
+							length147 := uint32(len(slice145))
+							result146 := witRuntime.Allocate(pinner, uintptr(length147*(2*4)), 4)
+							for index, element := range slice145 {
+								base := unsafe.Add(result146, index*(2*4))
+								utf8144 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8144)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8144)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length147)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result146)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).AllowedHosts.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).AllowedHosts.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+							slice149 := payload
+							length151 := uint32(len(slice149))
+							result150 := witRuntime.Allocate(pinner, uintptr(length151*(2*4)), 4)
+							for index, element := range slice149 {
+								base := unsafe.Add(result150, index*(2*4))
+								utf8148 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8148)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8148)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(length151)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(result150)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyDatetimeType:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+					case golem_core_types.SchemaTypeBodyDurationType:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+					case golem_core_types.SchemaTypeBodyQuantityType:
+						payload := (element).Body.QuantityType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+						utf8152 := unsafe.Pointer(unsafe.StringData((payload).BaseUnit))
+						pinner.Pin(utf8152)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).BaseUnit)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8152)))
+						slice154 := (payload).AllowedSuffixes
+						length156 := uint32(len(slice154))
+						result155 := witRuntime.Allocate(pinner, uintptr(length156*(2*4)), 4)
+						for index, element := range slice154 {
+							base := unsafe.Add(result155, index*(2*4))
+							utf8153 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8153)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8153)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length156)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result155)))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))) = (payload).Mantissa
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = (payload).Scale
+							utf8157 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+							pinner.Pin(utf8157)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))) = uint32(uint32(len((payload).Unit)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uintptr(uintptr(utf8157)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))) = (payload).Mantissa
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))) = (payload).Scale
+							utf8158 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+							pinner.Pin(utf8158)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))) = uint32(uint32(len((payload).Unit)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4))) = uint32(uintptr(uintptr(utf8158)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyUnionType:
+						payload := (element).Body.UnionType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+						slice178 := (payload).Branches
+						length180 := uint32(len(slice178))
+						result179 := witRuntime.Allocate(pinner, uintptr(length180*(23*4)), 4)
+						for index, element := range slice178 {
+							base := unsafe.Add(result179, index*(23*4))
+							utf8159 := unsafe.Pointer(unsafe.StringData((element).Tag))
+							pinner.Pin(utf8159)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Tag)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8159)))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+							switch (element).Discriminator.Tag() {
+							case golem_core_types.DiscriminatorRulePrefix:
+								payload := (element).Discriminator.Prefix()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+								utf8160 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8160)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8160)))
+
+							case golem_core_types.DiscriminatorRuleSuffix:
+								payload := (element).Discriminator.Suffix()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+								utf8161 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8161)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8161)))
+
+							case golem_core_types.DiscriminatorRuleContains:
+								payload := (element).Discriminator.Contains()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(2))
+								utf8162 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8162)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8162)))
+
+							case golem_core_types.DiscriminatorRuleRegex:
+								payload := (element).Discriminator.Regex()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(3))
+								utf8163 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8163)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8163)))
+
+							case golem_core_types.DiscriminatorRuleFieldEquals:
+								payload := (element).Discriminator.FieldEquals()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(4))
+								utf8164 := unsafe.Pointer(unsafe.StringData((payload).FieldName))
+								pinner.Pin(utf8164)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((payload).FieldName)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8164)))
+
+								switch (payload).Literal.Tag() {
+								case witTypes.OptionNone:
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+								case witTypes.OptionSome:
+									payload := (payload).Literal.Some()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+									utf8165 := unsafe.Pointer(unsafe.StringData(payload))
+									pinner.Pin(utf8165)
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8165)))
+
+								default:
+									panic("unreachable")
+								}
+
+							case golem_core_types.DiscriminatorRuleFieldAbsent:
+								payload := (element).Discriminator.FieldAbsent()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(5))
+								utf8166 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8166)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8166)))
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Doc.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Doc.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+								utf8167 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8167)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(utf8167)))
+
+							default:
+								panic("unreachable")
+							}
+							slice169 := ((element).Metadata).Aliases
+							length171 := uint32(len(slice169))
+							result170 := witRuntime.Allocate(pinner, uintptr(length171*(2*4)), 4)
+							for index, element := range slice169 {
+								base := unsafe.Add(result170, index*(2*4))
+								utf8168 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8168)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8168)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(length171)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(result170)))
+							slice173 := ((element).Metadata).Examples
+							length175 := uint32(len(slice173))
+							result174 := witRuntime.Allocate(pinner, uintptr(length175*(2*4)), 4)
+							for index, element := range slice173 {
+								base := unsafe.Add(result174, index*(2*4))
+								utf8172 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8172)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8172)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(length175)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(result174)))
+
+							switch ((element).Metadata).Deprecated.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Deprecated.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(1))
+								utf8176 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8176)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf8176)))
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Role.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Role.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.RoleMultimodal:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(0))
+
+								case golem_core_types.RoleUnstructuredText:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(1))
+
+								case golem_core_types.RoleUnstructuredBinary:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(2))
+
+								case golem_core_types.RoleOther:
+									payload := payload.Other()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(3))
+									utf8177 := unsafe.Pointer(unsafe.StringData(payload))
+									pinner.Pin(utf8177)
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uint32(len(payload)))
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(utf8177)))
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length180)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result179)))
+
+					case golem_core_types.SchemaTypeBodySecretType:
+						payload := (element).Body.SecretType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Inner
+
+						switch (payload).Category.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Category.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+							utf8181 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8181)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8181)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyQuotaTokenType:
+						payload := (element).Body.QuotaTokenType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+						switch (payload).ResourceName.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).ResourceName.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							utf8182 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8182)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf8182)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyFutureType:
+						payload := (element).Body.FutureType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyStreamType:
+						payload := (element).Body.StreamType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Doc.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Doc.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(1))
+						utf8183 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8183)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4))) = uint32(uintptr(uintptr(utf8183)))
+
+					default:
+						panic("unreachable")
+					}
+					slice185 := ((element).Metadata).Aliases
+					length187 := uint32(len(slice185))
+					result186 := witRuntime.Allocate(pinner, uintptr(length187*(2*4)), 4)
+					for index, element := range slice185 {
+						base := unsafe.Add(result186, index*(2*4))
+						utf8184 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8184)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8184)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length187)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result186)))
+					slice189 := ((element).Metadata).Examples
+					length191 := uint32(len(slice189))
+					result190 := witRuntime.Allocate(pinner, uintptr(length191*(2*4)), 4)
+					for index, element := range slice189 {
+						base := unsafe.Add(result190, index*(2*4))
+						utf8188 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8188)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8188)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length191)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result190)))
+
+					switch ((element).Metadata).Deprecated.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Deprecated.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(1))
+						utf8192 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8192)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4))) = uint32(uintptr(uintptr(utf8192)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Role.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Role.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.RoleMultimodal:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(0))
+
+						case golem_core_types.RoleUnstructuredText:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(1))
+
+						case golem_core_types.RoleUnstructuredBinary:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(2))
+
+						case golem_core_types.RoleOther:
+							payload := payload.Other()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(3))
+							utf8193 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8193)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4))) = uint32(uintptr(uintptr(utf8193)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				slice199 := ((payload).Graph).Defs
+				length201 := uint32(len(slice199))
+				result200 := witRuntime.Allocate(pinner, uintptr(length201*(6*4)), 4)
+				for index, element := range slice199 {
+					base := unsafe.Add(result200, index*(6*4))
+					utf8197 := unsafe.Pointer(unsafe.StringData((element).Id))
+					pinner.Pin(utf8197)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8197)))
+
+					switch (element).Name.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (element).Name.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+						utf8198 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8198)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8198)))
+
+					default:
+						panic("unreachable")
+					}
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body
+
+				}
+
+				slice231 := ((payload).Value).ValueNodes
+				length233 := uint32(len(slice231))
+				result232 := witRuntime.Allocate(pinner, uintptr(length233*(16+4*4)), 8)
+				for index, element := range slice231 {
+					base := unsafe.Add(result232, index*(16+4*4))
+
+					switch element.Tag() {
+					case golem_core_types.SchemaValueNodeBoolValue:
+						payload := element.BoolValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+						var result202 int32
+						if payload {
+							result202 = 1
+						} else {
+							result202 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result202)
+
+					case golem_core_types.SchemaValueNodeS8Value:
+						payload := element.S8Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+					case golem_core_types.SchemaValueNodeS16Value:
+						payload := element.S16Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+						*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+					case golem_core_types.SchemaValueNodeS32Value:
+						payload := element.S32Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeS64Value:
+						payload := element.S64Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeU8Value:
+						payload := element.U8Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+					case golem_core_types.SchemaValueNodeU16Value:
+						payload := element.U16Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+						*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+					case golem_core_types.SchemaValueNodeU32Value:
+						payload := element.U32Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+					case golem_core_types.SchemaValueNodeU64Value:
+						payload := element.U64Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+					case golem_core_types.SchemaValueNodeF32Value:
+						payload := element.F32Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+						*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeF64Value:
+						payload := element.F64Value()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+						*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaValueNodeCharValue:
+						payload := element.CharValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+					case golem_core_types.SchemaValueNodeStringValue:
+						payload := element.StringValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+						utf8203 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8203)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8203)))
+
+					case golem_core_types.SchemaValueNodeRecordValue:
+						payload := element.RecordValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+						slice204 := payload
+						length206 := uint32(len(slice204))
+						result205 := witRuntime.Allocate(pinner, uintptr(length206*4), 4)
+						for index, element := range slice204 {
+							base := unsafe.Add(result205, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length206)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result205)))
+
+					case golem_core_types.SchemaValueNodeVariantValue:
+						payload := element.VariantValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).Case)
+
+						switch (payload).Payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeEnumValue:
+						payload := element.EnumValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+					case golem_core_types.SchemaValueNodeFlagsValue:
+						payload := element.FlagsValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+						slice208 := payload
+						length210 := uint32(len(slice208))
+						result209 := witRuntime.Allocate(pinner, uintptr(length210*1), 1)
+						for index, element := range slice208 {
+							base := unsafe.Add(result209, index*1)
+							var result207 int32
+							if element {
+								result207 = 1
+							} else {
+								result207 = 0
+							}
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result207)
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length210)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result209)))
+
+					case golem_core_types.SchemaValueNodeTupleValue:
+						payload := element.TupleValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+						slice211 := payload
+						length213 := uint32(len(slice211))
+						result212 := witRuntime.Allocate(pinner, uintptr(length213*4), 4)
+						for index, element := range slice211 {
+							base := unsafe.Add(result212, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length213)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result212)))
+
+					case golem_core_types.SchemaValueNodeListValue:
+						payload := element.ListValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+						slice214 := payload
+						length216 := uint32(len(slice214))
+						result215 := witRuntime.Allocate(pinner, uintptr(length216*4), 4)
+						for index, element := range slice214 {
+							base := unsafe.Add(result215, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length216)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result215)))
+
+					case golem_core_types.SchemaValueNodeFixedListValue:
+						payload := element.FixedListValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+						slice217 := payload
+						length219 := uint32(len(slice217))
+						result218 := witRuntime.Allocate(pinner, uintptr(length219*4), 4)
+						for index, element := range slice217 {
+							base := unsafe.Add(result218, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length219)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result218)))
+
+					case golem_core_types.SchemaValueNodeMapValue:
+						payload := element.MapValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+						slice220 := payload
+						length222 := uint32(len(slice220))
+						result221 := witRuntime.Allocate(pinner, uintptr(length222*8), 4)
+						for index, element := range slice220 {
+							base := unsafe.Add(result221, index*8)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).Key
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (element).Value
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length222)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result221)))
+
+					case golem_core_types.SchemaValueNodeOptionValue:
+						payload := element.OptionValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeResultValue:
+						payload := element.ResultValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+
+						switch payload.Tag() {
+						case golem_core_types.ResultValuePayloadOkValue:
+							payload := payload.OkValue()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+							switch payload.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := payload.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+								*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+							default:
+								panic("unreachable")
+							}
+
+						case golem_core_types.ResultValuePayloadErrValue:
+							payload := payload.ErrValue()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := payload.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+								*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeTextValue:
+						payload := element.TextValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+						utf8223 := unsafe.Pointer(unsafe.StringData((payload).Text))
+						pinner.Pin(utf8223)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8223)))
+
+						switch (payload).Language.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Language.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+							utf8224 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8224)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8224)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodeBinaryValue:
+						payload := element.BinaryValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+						data225 := unsafe.Pointer(unsafe.SliceData((payload).Bytes))
+						pinner.Pin(data225)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data225)))
+
+						switch (payload).MimeType.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MimeType.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+							utf8226 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8226)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8226)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaValueNodePathValue:
+						payload := element.PathValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+						utf8227 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8227)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8227)))
+
+					case golem_core_types.SchemaValueNodeUrlValue:
+						payload := element.UrlValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+						utf8228 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8228)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8228)))
+
+					case golem_core_types.SchemaValueNodeDatetimeValue:
+						payload := element.DatetimeValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Seconds
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = int32((payload).Nanoseconds)
+
+					case golem_core_types.SchemaValueNodeDurationValue:
+						payload := element.DurationValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Nanoseconds
+
+					case golem_core_types.SchemaValueNodeQuantityValueNode:
+						payload := element.QuantityValueNode()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Mantissa
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Scale
+						utf8229 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+						pinner.Pin(utf8229)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uint32(len((payload).Unit)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))) = uint32(uintptr(uintptr(utf8229)))
+
+					case golem_core_types.SchemaValueNodeUnionValue:
+						payload := element.UnionValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+						utf8230 := unsafe.Pointer(unsafe.StringData((payload).Tag))
+						pinner.Pin(utf8230)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8230)))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Body
+
+					case golem_core_types.SchemaValueNodeSecretValue:
+						payload := element.SecretValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+					case golem_core_types.SchemaValueNodeQuotaTokenHandle:
+						payload := element.QuotaTokenHandle()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				variant234 = int32(4)
+				variant235 = uintptr(result195)
+				variant236 = length196
+				variant237 = uintptr(result200)
+				variant238 = length201
+				variant239 = ((payload).Graph).Root
+				variant240 = uintptr(result232)
+				variant241 = length233
+				variant242 = ((payload).Value).Root
+
+			default:
+				panic("unreachable")
+			}
+
+			option243 = int32(1)
+			option244 = variant234
+			option245 = variant235
+			option246 = variant236
+			option247 = variant237
+			option248 = variant238
+			option249 = variant239
+			option250 = variant240
+			option251 = variant241
+			option252 = variant242
+		default:
+			panic("unreachable")
+		}
+		wasm_export_task_return_golem_agent_guest_invoke(option243, option244, option245, option246, option247, option248, option249, option250, option251, option252)
+
+	}))
+}
+
+//go:wasmexport [callback][async-lift]golem:agent/guest@2.0.0#invoke
+func wasm_export_callback_golem_agent_guest_invoke(event0 uint32, event1 uint32, event2 uint32) uint32 {
+	return witAsync.Callback(event0, event1, event2)
+}
+
+//go:wasmimport [export]golem:agent/guest@2.0.0 [task-return]invoke
+func wasm_export_task_return_golem_agent_guest_invoke(arg0 int32, arg1 int32, arg2 uintptr, arg3 uint32, arg4 uintptr, arg5 uint32, arg6 int32, arg7 uintptr, arg8 uint32, arg9 int32)
+
+//go:wasmexport golem:agent/guest@2.0.0#get-definition
+func wasm_export_golem_agent_guest_get_definition() uintptr {
+
+	pinner := &syncExportPinner
+	result := export_golem_agent_guest.GetDefinition()
+	utf8 := unsafe.Pointer(unsafe.StringData((result).TypeName))
+	pinner.Pin(utf8)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), 4)) = uint32(uint32(len((result).TypeName)))
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), 0)) = uint32(uintptr(uintptr(utf8)))
+	utf80 := unsafe.Pointer(unsafe.StringData((result).Description))
+	pinner.Pin(utf80)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (3 * 4))) = uint32(uint32(len((result).Description)))
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (2 * 4))) = uint32(uintptr(uintptr(utf80)))
+	utf81 := unsafe.Pointer(unsafe.StringData((result).SourceLanguage))
+	pinner.Pin(utf81)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (5 * 4))) = uint32(uint32(len((result).SourceLanguage)))
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (4 * 4))) = uint32(uintptr(uintptr(utf81)))
+	slice118 := ((result).Schema).TypeNodes
+	length120 := uint32(len(slice118))
+	result119 := witRuntime.Allocate(pinner, uintptr(length120*(56+22*4)), 8)
+	for index, element := range slice118 {
+		base := unsafe.Add(result119, index*(56+22*4))
+
+		switch (element).Body.Tag() {
+		case golem_core_types.SchemaTypeBodyRefType:
+			payload := (element).Body.RefType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaTypeBodyBoolType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+		case golem_core_types.SchemaTypeBodyS8Type:
+			payload := (element).Body.S8Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf82 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf82)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf82)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyS16Type:
+			payload := (element).Body.S16Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf83 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf83)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf83)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyS32Type:
+			payload := (element).Body.S32Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf84 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf84)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf84)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyS64Type:
+			payload := (element).Body.S64Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf85 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf85)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf85)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU8Type:
+			payload := (element).Body.U8Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf86 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf86)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf86)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU16Type:
+			payload := (element).Body.U16Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf87 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf87)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf87)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU32Type:
+			payload := (element).Body.U32Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf88 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf88)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf88)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyU64Type:
+			payload := (element).Body.U64Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf89 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf89)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf89)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyF32Type:
+			payload := (element).Body.F32Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf810 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf810)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf810)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyF64Type:
+			payload := (element).Body.F64Type()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.NumericBoundSigned:
+						payload := payload.Signed()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+					case golem_core_types.NumericBoundUnsigned:
+						payload := payload.Unsigned()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					case golem_core_types.NumericBoundFloatBits:
+						payload := payload.FloatBits()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Unit.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Unit.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+					utf811 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf811)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf811)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyCharType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+
+		case golem_core_types.SchemaTypeBodyStringType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+
+		case golem_core_types.SchemaTypeBodyRecordType:
+			payload := (element).Body.RecordType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+			slice22 := payload
+			length24 := uint32(len(slice22))
+			result23 := witRuntime.Allocate(pinner, uintptr(length24*(17*4)), 4)
+			for index, element := range slice22 {
+				base := unsafe.Add(result23, index*(17*4))
+				utf812 := unsafe.Pointer(unsafe.StringData((element).Name))
+				pinner.Pin(utf812)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf812)))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+					utf813 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf813)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf813)))
+
+				default:
+					panic("unreachable")
+				}
+				slice := ((element).Metadata).Aliases
+				length := uint32(len(slice))
+				result15 := witRuntime.Allocate(pinner, uintptr(length*(2*4)), 4)
+				for index, element := range slice {
+					base := unsafe.Add(result15, index*(2*4))
+					utf814 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf814)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf814)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result15)))
+				slice17 := ((element).Metadata).Examples
+				length19 := uint32(len(slice17))
+				result18 := witRuntime.Allocate(pinner, uintptr(length19*(2*4)), 4)
+				for index, element := range slice17 {
+					base := unsafe.Add(result18, index*(2*4))
+					utf816 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf816)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf816)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = uint32(length19)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result18)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(1))
+					utf820 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf820)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf820)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(3))
+						utf821 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf821)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uintptr(uintptr(utf821)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length24)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result23)))
+
+		case golem_core_types.SchemaTypeBodyVariantType:
+			payload := (element).Body.VariantType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+			slice37 := payload
+			length39 := uint32(len(slice37))
+			result38 := witRuntime.Allocate(pinner, uintptr(length39*(8+16*4)), 4)
+			for index, element := range slice37 {
+				base := unsafe.Add(result38, index*(8+16*4))
+				utf825 := unsafe.Pointer(unsafe.StringData((element).Name))
+				pinner.Pin(utf825)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf825)))
+
+				switch (element).Payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (element).Payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+					utf826 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf826)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf826)))
+
+				default:
+					panic("unreachable")
+				}
+				slice28 := ((element).Metadata).Aliases
+				length30 := uint32(len(slice28))
+				result29 := witRuntime.Allocate(pinner, uintptr(length30*(2*4)), 4)
+				for index, element := range slice28 {
+					base := unsafe.Add(result29, index*(2*4))
+					utf827 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf827)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf827)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length30)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result29)))
+				slice32 := ((element).Metadata).Examples
+				length34 := uint32(len(slice32))
+				result33 := witRuntime.Allocate(pinner, uintptr(length34*(2*4)), 4)
+				for index, element := range slice32 {
+					base := unsafe.Add(result33, index*(2*4))
+					utf831 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf831)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf831)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length34)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result33)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+					utf835 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf835)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf835)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+						utf836 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf836)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf836)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length39)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result38)))
+
+		case golem_core_types.SchemaTypeBodyEnumType:
+			payload := (element).Body.EnumType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+			slice41 := payload
+			length43 := uint32(len(slice41))
+			result42 := witRuntime.Allocate(pinner, uintptr(length43*(2*4)), 4)
+			for index, element := range slice41 {
+				base := unsafe.Add(result42, index*(2*4))
+				utf840 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf840)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf840)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length43)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result42)))
+
+		case golem_core_types.SchemaTypeBodyFlagsType:
+			payload := (element).Body.FlagsType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+			slice45 := payload
+			length47 := uint32(len(slice45))
+			result46 := witRuntime.Allocate(pinner, uintptr(length47*(2*4)), 4)
+			for index, element := range slice45 {
+				base := unsafe.Add(result46, index*(2*4))
+				utf844 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf844)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf844)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length47)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result46)))
+
+		case golem_core_types.SchemaTypeBodyTupleType:
+			payload := (element).Body.TupleType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+			slice48 := payload
+			length50 := uint32(len(slice48))
+			result49 := witRuntime.Allocate(pinner, uintptr(length50*4), 4)
+			for index, element := range slice48 {
+				base := unsafe.Add(result49, index*4)
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length50)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result49)))
+
+		case golem_core_types.SchemaTypeBodyListType:
+			payload := (element).Body.ListType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaTypeBodyFixedListType:
+			payload := (element).Body.FixedListType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Element
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Length)
+
+		case golem_core_types.SchemaTypeBodyMapType:
+			payload := (element).Body.MapType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Key
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Value
+
+		case golem_core_types.SchemaTypeBodyOptionType:
+			payload := (element).Body.OptionType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+		case golem_core_types.SchemaTypeBodyResultType:
+			payload := (element).Body.ResultType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+			switch (payload).Ok.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Ok.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).Err.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Err.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyTextType:
+			payload := (element).Body.TextType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+			switch (payload).Languages.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Languages.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				slice52 := payload
+				length54 := uint32(len(slice52))
+				result53 := witRuntime.Allocate(pinner, uintptr(length54*(2*4)), 4)
+				for index, element := range slice52 {
+					base := unsafe.Add(result53, index*(2*4))
+					utf851 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf851)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf851)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length54)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result53)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MinLength.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MinLength.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MaxLength.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MaxLength.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).Regex.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Regex.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(1))
+				utf855 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf855)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = uint32(uintptr(uintptr(utf855)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyBinaryType:
+			payload := (element).Body.BinaryType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+
+			switch (payload).MimeTypes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MimeTypes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				slice57 := payload
+				length59 := uint32(len(slice57))
+				result58 := witRuntime.Allocate(pinner, uintptr(length59*(2*4)), 4)
+				for index, element := range slice57 {
+					base := unsafe.Add(result58, index*(2*4))
+					utf856 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf856)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf856)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length59)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result58)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MinBytes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MinBytes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).MaxBytes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).MaxBytes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyPathType:
+			payload := (element).Body.PathType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Direction))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Kind))
+
+			switch (payload).AllowedMimeTypes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedMimeTypes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+				slice61 := payload
+				length63 := uint32(len(slice61))
+				result62 := witRuntime.Allocate(pinner, uintptr(length63*(2*4)), 4)
+				for index, element := range slice61 {
+					base := unsafe.Add(result62, index*(2*4))
+					utf860 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf860)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf860)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length63)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result62)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).AllowedExtensions.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedExtensions.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+				slice65 := payload
+				length67 := uint32(len(slice65))
+				result66 := witRuntime.Allocate(pinner, uintptr(length67*(2*4)), 4)
+				for index, element := range slice65 {
+					base := unsafe.Add(result66, index*(2*4))
+					utf864 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf864)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf864)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length67)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result66)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyUrlType:
+			payload := (element).Body.UrlType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+
+			switch (payload).AllowedSchemes.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedSchemes.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				slice69 := payload
+				length71 := uint32(len(slice69))
+				result70 := witRuntime.Allocate(pinner, uintptr(length71*(2*4)), 4)
+				for index, element := range slice69 {
+					base := unsafe.Add(result70, index*(2*4))
+					utf868 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf868)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf868)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length71)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result70)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).AllowedHosts.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).AllowedHosts.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+				slice73 := payload
+				length75 := uint32(len(slice73))
+				result74 := witRuntime.Allocate(pinner, uintptr(length75*(2*4)), 4)
+				for index, element := range slice73 {
+					base := unsafe.Add(result74, index*(2*4))
+					utf872 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf872)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf872)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(length75)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(result74)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyDatetimeType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+		case golem_core_types.SchemaTypeBodyDurationType:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+		case golem_core_types.SchemaTypeBodyQuantityType:
+			payload := (element).Body.QuantityType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+			utf876 := unsafe.Pointer(unsafe.StringData((payload).BaseUnit))
+			pinner.Pin(utf876)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).BaseUnit)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf876)))
+			slice78 := (payload).AllowedSuffixes
+			length80 := uint32(len(slice78))
+			result79 := witRuntime.Allocate(pinner, uintptr(length80*(2*4)), 4)
+			for index, element := range slice78 {
+				base := unsafe.Add(result79, index*(2*4))
+				utf877 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf877)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf877)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result79)))
+
+			switch (payload).Min.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Min.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))) = (payload).Mantissa
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = (payload).Scale
+				utf881 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+				pinner.Pin(utf881)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))) = uint32(uint32(len((payload).Unit)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uintptr(uintptr(utf881)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (payload).Max.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Max.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(1))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))) = (payload).Mantissa
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))) = (payload).Scale
+				utf882 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+				pinner.Pin(utf882)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))) = uint32(uint32(len((payload).Unit)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4))) = uint32(uintptr(uintptr(utf882)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyUnionType:
+			payload := (element).Body.UnionType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+			slice102 := (payload).Branches
+			length104 := uint32(len(slice102))
+			result103 := witRuntime.Allocate(pinner, uintptr(length104*(23*4)), 4)
+			for index, element := range slice102 {
+				base := unsafe.Add(result103, index*(23*4))
+				utf883 := unsafe.Pointer(unsafe.StringData((element).Tag))
+				pinner.Pin(utf883)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Tag)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf883)))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+				switch (element).Discriminator.Tag() {
+				case golem_core_types.DiscriminatorRulePrefix:
+					payload := (element).Discriminator.Prefix()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+					utf884 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf884)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf884)))
+
+				case golem_core_types.DiscriminatorRuleSuffix:
+					payload := (element).Discriminator.Suffix()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+					utf885 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf885)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf885)))
+
+				case golem_core_types.DiscriminatorRuleContains:
+					payload := (element).Discriminator.Contains()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(2))
+					utf886 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf886)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf886)))
+
+				case golem_core_types.DiscriminatorRuleRegex:
+					payload := (element).Discriminator.Regex()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(3))
+					utf887 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf887)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf887)))
+
+				case golem_core_types.DiscriminatorRuleFieldEquals:
+					payload := (element).Discriminator.FieldEquals()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(4))
+					utf888 := unsafe.Pointer(unsafe.StringData((payload).FieldName))
+					pinner.Pin(utf888)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((payload).FieldName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf888)))
+
+					switch (payload).Literal.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Literal.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+						utf889 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf889)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf889)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.DiscriminatorRuleFieldAbsent:
+					payload := (element).Discriminator.FieldAbsent()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(5))
+					utf890 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf890)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf890)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+					utf891 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf891)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(utf891)))
+
+				default:
+					panic("unreachable")
+				}
+				slice93 := ((element).Metadata).Aliases
+				length95 := uint32(len(slice93))
+				result94 := witRuntime.Allocate(pinner, uintptr(length95*(2*4)), 4)
+				for index, element := range slice93 {
+					base := unsafe.Add(result94, index*(2*4))
+					utf892 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf892)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf892)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(length95)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(result94)))
+				slice97 := ((element).Metadata).Examples
+				length99 := uint32(len(slice97))
+				result98 := witRuntime.Allocate(pinner, uintptr(length99*(2*4)), 4)
+				for index, element := range slice97 {
+					base := unsafe.Add(result98, index*(2*4))
+					utf896 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf896)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf896)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(length99)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(result98)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(1))
+					utf8100 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8100)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf8100)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(3))
+						utf8101 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8101)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(utf8101)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length104)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result103)))
+
+		case golem_core_types.SchemaTypeBodySecretType:
+			payload := (element).Body.SecretType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Inner
+
+			switch (payload).Category.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).Category.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+				utf8105 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8105)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8105)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyQuotaTokenType:
+			payload := (element).Body.QuotaTokenType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+			switch (payload).ResourceName.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (payload).ResourceName.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				utf8106 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8106)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf8106)))
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyFutureType:
+			payload := (element).Body.FutureType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		case golem_core_types.SchemaTypeBodyStreamType:
+			payload := (element).Body.StreamType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+			switch payload.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := payload.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+		default:
+			panic("unreachable")
+		}
+
+		switch ((element).Metadata).Doc.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Metadata).Doc.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(1))
+			utf8107 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8107)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4))) = uint32(uintptr(uintptr(utf8107)))
+
+		default:
+			panic("unreachable")
+		}
+		slice109 := ((element).Metadata).Aliases
+		length111 := uint32(len(slice109))
+		result110 := witRuntime.Allocate(pinner, uintptr(length111*(2*4)), 4)
+		for index, element := range slice109 {
+			base := unsafe.Add(result110, index*(2*4))
+			utf8108 := unsafe.Pointer(unsafe.StringData(element))
+			pinner.Pin(utf8108)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8108)))
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length111)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result110)))
+		slice113 := ((element).Metadata).Examples
+		length115 := uint32(len(slice113))
+		result114 := witRuntime.Allocate(pinner, uintptr(length115*(2*4)), 4)
+		for index, element := range slice113 {
+			base := unsafe.Add(result114, index*(2*4))
+			utf8112 := unsafe.Pointer(unsafe.StringData(element))
+			pinner.Pin(utf8112)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8112)))
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length115)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result114)))
+
+		switch ((element).Metadata).Deprecated.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Metadata).Deprecated.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(1))
+			utf8116 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8116)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4))) = uint32(uintptr(uintptr(utf8116)))
+
+		default:
+			panic("unreachable")
+		}
+
+		switch ((element).Metadata).Role.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Metadata).Role.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(1))
+
+			switch payload.Tag() {
+			case golem_core_types.RoleMultimodal:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(0))
+
+			case golem_core_types.RoleUnstructuredText:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(1))
+
+			case golem_core_types.RoleUnstructuredBinary:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(2))
+
+			case golem_core_types.RoleOther:
+				payload := payload.Other()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(3))
+				utf8117 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8117)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4))) = uint32(uintptr(uintptr(utf8117)))
+
+			default:
+				panic("unreachable")
+			}
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (7 * 4))) = uint32(length120)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (6 * 4))) = uint32(uintptr(uintptr(result119)))
+	slice123 := ((result).Schema).Defs
+	length125 := uint32(len(slice123))
+	result124 := witRuntime.Allocate(pinner, uintptr(length125*(6*4)), 4)
+	for index, element := range slice123 {
+		base := unsafe.Add(result124, index*(6*4))
+		utf8121 := unsafe.Pointer(unsafe.StringData((element).Id))
+		pinner.Pin(utf8121)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8121)))
+
+		switch (element).Name.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := (element).Name.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+			utf8122 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8122)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8122)))
+
+		default:
+			panic("unreachable")
+		}
+		*(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body
+
+	}
+
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (9 * 4))) = uint32(length125)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (8 * 4))) = uint32(uintptr(uintptr(result124)))
+	*(*int32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (10 * 4))) = ((result).Schema).Root
+
+	switch ((result).Constructor).Name.Tag() {
+	case witTypes.OptionNone:
+		*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (11 * 4))) = int8(int32(0))
+
+	case witTypes.OptionSome:
+		payload := ((result).Constructor).Name.Some()
+		*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (11 * 4))) = int8(int32(1))
+		utf8126 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf8126)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (13 * 4))) = uint32(uint32(len(payload)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (12 * 4))) = uint32(uintptr(uintptr(utf8126)))
+
+	default:
+		panic("unreachable")
+	}
+	utf8127 := unsafe.Pointer(unsafe.StringData(((result).Constructor).Description))
+	pinner.Pin(utf8127)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (15 * 4))) = uint32(uint32(len(((result).Constructor).Description)))
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (14 * 4))) = uint32(uintptr(uintptr(utf8127)))
+
+	switch ((result).Constructor).PromptHint.Tag() {
+	case witTypes.OptionNone:
+		*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (16 * 4))) = int8(int32(0))
+
+	case witTypes.OptionSome:
+		payload := ((result).Constructor).PromptHint.Some()
+		*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (16 * 4))) = int8(int32(1))
+		utf8128 := unsafe.Pointer(unsafe.StringData(payload))
+		pinner.Pin(utf8128)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (18 * 4))) = uint32(uint32(len(payload)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (17 * 4))) = uint32(uintptr(uintptr(utf8128)))
+
+	default:
+		panic("unreachable")
+	}
+
+	switch ((result).Constructor).InputSchema.Tag() {
+	case golem_agent_common.InputSchemaParameters:
+		payload := ((result).Constructor).InputSchema.Parameters()
+		*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (19 * 4))) = int8(int32(0))
+		slice141 := payload
+		length143 := uint32(len(slice141))
+		result142 := witRuntime.Allocate(pinner, uintptr(length143*(8+16*4)), 4)
+		for index, element := range slice141 {
+			base := unsafe.Add(result142, index*(8+16*4))
+			utf8129 := unsafe.Pointer(unsafe.StringData((element).Name))
+			pinner.Pin(utf8129)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8129)))
+
+			switch (element).Source.Tag() {
+			case golem_agent_common.FieldSourceUserSupplied:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+			case golem_agent_common.FieldSourceAutoInjected:
+				payload := (element).Source.AutoInjected()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))) = int8(int32(payload))
+
+			default:
+				panic("unreachable")
+			}
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = (element).Schema
+
+			switch ((element).Metadata).Doc.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := ((element).Metadata).Doc.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+				utf8130 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8130)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8130)))
+
+			default:
+				panic("unreachable")
+			}
+			slice132 := ((element).Metadata).Aliases
+			length134 := uint32(len(slice132))
+			result133 := witRuntime.Allocate(pinner, uintptr(length134*(2*4)), 4)
+			for index, element := range slice132 {
+				base := unsafe.Add(result133, index*(2*4))
+				utf8131 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf8131)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8131)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length134)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result133)))
+			slice136 := ((element).Metadata).Examples
+			length138 := uint32(len(slice136))
+			result137 := witRuntime.Allocate(pinner, uintptr(length138*(2*4)), 4)
+			for index, element := range slice136 {
+				base := unsafe.Add(result137, index*(2*4))
+				utf8135 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf8135)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8135)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length138)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result137)))
+
+			switch ((element).Metadata).Deprecated.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := ((element).Metadata).Deprecated.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+				utf8139 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8139)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf8139)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch ((element).Metadata).Role.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := ((element).Metadata).Role.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+				switch payload.Tag() {
+				case golem_core_types.RoleMultimodal:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+				case golem_core_types.RoleUnstructuredText:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+				case golem_core_types.RoleUnstructuredBinary:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+				case golem_core_types.RoleOther:
+					payload := payload.Other()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+					utf8140 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8140)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf8140)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (21 * 4))) = uint32(length143)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (20 * 4))) = uint32(uintptr(uintptr(result142)))
+
+	default:
+		panic("unreachable")
+	}
+	slice188 := (result).Methods
+	length190 := uint32(len(slice188))
+	result189 := witRuntime.Allocate(pinner, uintptr(length190*(40+12*4)), 8)
+	for index, element := range slice188 {
+		base := unsafe.Add(result189, index*(40+12*4))
+		utf8144 := unsafe.Pointer(unsafe.StringData((element).Name))
+		pinner.Pin(utf8144)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8144)))
+		utf8145 := unsafe.Pointer(unsafe.StringData((element).Description))
+		pinner.Pin(utf8145)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).Description)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8145)))
+		slice168 := (element).HttpEndpoint
+		length170 := uint32(len(slice168))
+		result169 := witRuntime.Allocate(pinner, uintptr(length170*(12*4)), 4)
+		for index, element := range slice168 {
+			base := unsafe.Add(result169, index*(12*4))
+
+			switch (element).HttpMethod.Tag() {
+			case golem_agent_common.HttpMethodGet:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+
+			case golem_agent_common.HttpMethodHead:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+			case golem_agent_common.HttpMethodPost:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+			case golem_agent_common.HttpMethodPut:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+			case golem_agent_common.HttpMethodDelete:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+			case golem_agent_common.HttpMethodConnect:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+			case golem_agent_common.HttpMethodOptions:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+			case golem_agent_common.HttpMethodTrace:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+			case golem_agent_common.HttpMethodPatch:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+			case golem_agent_common.HttpMethodCustom:
+				payload := (element).HttpMethod.Custom()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+				utf8146 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8146)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8146)))
+
+			default:
+				panic("unreachable")
+			}
+			slice150 := (element).PathSuffix
+			length152 := uint32(len(slice150))
+			result151 := witRuntime.Allocate(pinner, uintptr(length152*(3*4)), 4)
+			for index, element := range slice150 {
+				base := unsafe.Add(result151, index*(3*4))
+
+				switch element.Tag() {
+				case golem_agent_common.PathSegmentLiteral:
+					payload := element.Literal()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+					utf8147 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8147)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8147)))
+
+				case golem_agent_common.PathSegmentSystemVariable:
+					payload := element.SystemVariable()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 4)) = int8(int32(payload))
+
+				case golem_agent_common.PathSegmentPathVariable:
+					payload := element.PathVariable()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+					utf8148 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+					pinner.Pin(utf8148)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8148)))
+
+				case golem_agent_common.PathSegmentRemainingPathVariable:
+					payload := element.RemainingPathVariable()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+					utf8149 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+					pinner.Pin(utf8149)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8149)))
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(length152)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(result151)))
+			slice155 := (element).HeaderVars
+			length157 := uint32(len(slice155))
+			result156 := witRuntime.Allocate(pinner, uintptr(length157*(4*4)), 4)
+			for index, element := range slice155 {
+				base := unsafe.Add(result156, index*(4*4))
+				utf8153 := unsafe.Pointer(unsafe.StringData((element).HeaderName))
+				pinner.Pin(utf8153)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).HeaderName)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8153)))
+				utf8154 := unsafe.Pointer(unsafe.StringData((element).VariableName))
+				pinner.Pin(utf8154)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8154)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(length157)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uintptr(uintptr(result156)))
+			slice160 := (element).QueryVars
+			length162 := uint32(len(slice160))
+			result161 := witRuntime.Allocate(pinner, uintptr(length162*(4*4)), 4)
+			for index, element := range slice160 {
+				base := unsafe.Add(result161, index*(4*4))
+				utf8158 := unsafe.Pointer(unsafe.StringData((element).QueryParamName))
+				pinner.Pin(utf8158)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).QueryParamName)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8158)))
+				utf8159 := unsafe.Pointer(unsafe.StringData((element).VariableName))
+				pinner.Pin(utf8159)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8159)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(length162)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(result161)))
+
+			switch (element).AuthDetails.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (element).AuthDetails.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+				var result163 int32
+				if (payload).Required {
+					result163 = 1
+				} else {
+					result163 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 9*4))) = int8(result163)
+
+			default:
+				panic("unreachable")
+			}
+			slice165 := ((element).CorsOptions).AllowedPatterns
+			length167 := uint32(len(slice165))
+			result166 := witRuntime.Allocate(pinner, uintptr(length167*(2*4)), 4)
+			for index, element := range slice165 {
+				base := unsafe.Add(result166, index*(2*4))
+				utf8164 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf8164)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8164)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length167)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result166)))
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(length170)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(result169)))
+
+		switch (element).PromptHint.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := (element).PromptHint.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+			utf8171 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8171)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8171)))
+
+		default:
+			panic("unreachable")
+		}
+
+		switch (element).InputSchema.Tag() {
+		case golem_agent_common.InputSchemaParameters:
+			payload := (element).InputSchema.Parameters()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+			slice184 := payload
+			length186 := uint32(len(slice184))
+			result185 := witRuntime.Allocate(pinner, uintptr(length186*(8+16*4)), 4)
+			for index, element := range slice184 {
+				base := unsafe.Add(result185, index*(8+16*4))
+				utf8172 := unsafe.Pointer(unsafe.StringData((element).Name))
+				pinner.Pin(utf8172)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8172)))
+
+				switch (element).Source.Tag() {
+				case golem_agent_common.FieldSourceUserSupplied:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+				case golem_agent_common.FieldSourceAutoInjected:
+					payload := (element).Source.AutoInjected()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))) = int8(int32(payload))
+
+				default:
+					panic("unreachable")
+				}
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = (element).Schema
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+					utf8173 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8173)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8173)))
+
+				default:
+					panic("unreachable")
+				}
+				slice175 := ((element).Metadata).Aliases
+				length177 := uint32(len(slice175))
+				result176 := witRuntime.Allocate(pinner, uintptr(length177*(2*4)), 4)
+				for index, element := range slice175 {
+					base := unsafe.Add(result176, index*(2*4))
+					utf8174 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8174)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8174)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length177)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result176)))
+				slice179 := ((element).Metadata).Examples
+				length181 := uint32(len(slice179))
+				result180 := witRuntime.Allocate(pinner, uintptr(length181*(2*4)), 4)
+				for index, element := range slice179 {
+					base := unsafe.Add(result180, index*(2*4))
+					utf8178 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8178)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8178)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length181)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result180)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+					utf8182 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8182)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf8182)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+						utf8183 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8183)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf8183)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length186)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result185)))
+
+		default:
+			panic("unreachable")
+		}
+
+		switch (element).OutputSchema.Tag() {
+		case golem_agent_common.OutputSchemaUnit:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = int8(int32(0))
+
+		case golem_agent_common.OutputSchemaSingle:
+			payload := (element).OutputSchema.Single()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = int8(int32(1))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 12*4))) = payload
+
+		default:
+			panic("unreachable")
+		}
+
+		switch (element).ReadOnly.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := (element).ReadOnly.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+			switch (payload).CachePolicy.Tag() {
+			case golem_agent_common.CachePolicyNoCache:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4))) = int8(int32(0))
+
+			case golem_agent_common.CachePolicyUntilWrite:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4))) = int8(int32(1))
+
+			case golem_agent_common.CachePolicyTtl:
+				payload := (payload).CachePolicy.Ttl()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4))) = int8(int32(2))
+				*(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 12*4))) = int64(payload)
+
+			default:
+				panic("unreachable")
+			}
+			var result187 int32
+			if (payload).UsesPrincipal {
+				result187 = 1
+			} else {
+				result187 = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))) = int8(result187)
+
+		default:
+			panic("unreachable")
+		}
+
+	}
+
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (23 * 4))) = uint32(length190)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (22 * 4))) = uint32(uintptr(uintptr(result189)))
+	slice384 := (result).Dependencies
+	length386 := uint32(len(slice384))
+	result385 := witRuntime.Allocate(pinner, uintptr(length386*(23*4)), 4)
+	for index, element := range slice384 {
+		base := unsafe.Add(result385, index*(23*4))
+		utf8191 := unsafe.Pointer(unsafe.StringData((element).TypeName))
+		pinner.Pin(utf8191)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).TypeName)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8191)))
+
+		switch (element).Description.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := (element).Description.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+			utf8192 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8192)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8192)))
+
+		default:
+			panic("unreachable")
+		}
+		slice311 := ((element).Schema).TypeNodes
+		length313 := uint32(len(slice311))
+		result312 := witRuntime.Allocate(pinner, uintptr(length313*(56+22*4)), 8)
+		for index, element := range slice311 {
+			base := unsafe.Add(result312, index*(56+22*4))
+
+			switch (element).Body.Tag() {
+			case golem_core_types.SchemaTypeBodyRefType:
+				payload := (element).Body.RefType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+			case golem_core_types.SchemaTypeBodyBoolType:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+			case golem_core_types.SchemaTypeBodyS8Type:
+				payload := (element).Body.S8Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf8193 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8193)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8193)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyS16Type:
+				payload := (element).Body.S16Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf8194 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8194)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8194)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyS32Type:
+				payload := (element).Body.S32Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf8195 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8195)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8195)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyS64Type:
+				payload := (element).Body.S64Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf8196 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8196)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8196)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyU8Type:
+				payload := (element).Body.U8Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf8197 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8197)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8197)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyU16Type:
+				payload := (element).Body.U16Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf8198 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8198)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8198)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyU32Type:
+				payload := (element).Body.U32Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf8199 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8199)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8199)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyU64Type:
+				payload := (element).Body.U64Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf8200 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8200)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8200)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyF32Type:
+				payload := (element).Body.F32Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf8201 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8201)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8201)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyF64Type:
+				payload := (element).Body.F64Type()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.NumericBoundSigned:
+							payload := payload.Signed()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+						case golem_core_types.NumericBoundUnsigned:
+							payload := payload.Unsigned()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						case golem_core_types.NumericBoundFloatBits:
+							payload := payload.FloatBits()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Unit.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Unit.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+						utf8202 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8202)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8202)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyCharType:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+
+			case golem_core_types.SchemaTypeBodyStringType:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+
+			case golem_core_types.SchemaTypeBodyRecordType:
+				payload := (element).Body.RecordType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+				slice215 := payload
+				length217 := uint32(len(slice215))
+				result216 := witRuntime.Allocate(pinner, uintptr(length217*(17*4)), 4)
+				for index, element := range slice215 {
+					base := unsafe.Add(result216, index*(17*4))
+					utf8203 := unsafe.Pointer(unsafe.StringData((element).Name))
+					pinner.Pin(utf8203)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8203)))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+					switch ((element).Metadata).Doc.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Doc.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+						utf8204 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8204)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8204)))
+
+					default:
+						panic("unreachable")
+					}
+					slice206 := ((element).Metadata).Aliases
+					length208 := uint32(len(slice206))
+					result207 := witRuntime.Allocate(pinner, uintptr(length208*(2*4)), 4)
+					for index, element := range slice206 {
+						base := unsafe.Add(result207, index*(2*4))
+						utf8205 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8205)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8205)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length208)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result207)))
+					slice210 := ((element).Metadata).Examples
+					length212 := uint32(len(slice210))
+					result211 := witRuntime.Allocate(pinner, uintptr(length212*(2*4)), 4)
+					for index, element := range slice210 {
+						base := unsafe.Add(result211, index*(2*4))
+						utf8209 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8209)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8209)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = uint32(length212)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result211)))
+
+					switch ((element).Metadata).Deprecated.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Deprecated.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(1))
+						utf8213 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8213)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf8213)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Role.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Role.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.RoleMultimodal:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(0))
+
+						case golem_core_types.RoleUnstructuredText:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(1))
+
+						case golem_core_types.RoleUnstructuredBinary:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(2))
+
+						case golem_core_types.RoleOther:
+							payload := payload.Other()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(3))
+							utf8214 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8214)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uintptr(uintptr(utf8214)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length217)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result216)))
+
+			case golem_core_types.SchemaTypeBodyVariantType:
+				payload := (element).Body.VariantType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+				slice230 := payload
+				length232 := uint32(len(slice230))
+				result231 := witRuntime.Allocate(pinner, uintptr(length232*(8+16*4)), 4)
+				for index, element := range slice230 {
+					base := unsafe.Add(result231, index*(8+16*4))
+					utf8218 := unsafe.Pointer(unsafe.StringData((element).Name))
+					pinner.Pin(utf8218)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8218)))
+
+					switch (element).Payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (element).Payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = payload
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Doc.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Doc.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						utf8219 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8219)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8219)))
+
+					default:
+						panic("unreachable")
+					}
+					slice221 := ((element).Metadata).Aliases
+					length223 := uint32(len(slice221))
+					result222 := witRuntime.Allocate(pinner, uintptr(length223*(2*4)), 4)
+					for index, element := range slice221 {
+						base := unsafe.Add(result222, index*(2*4))
+						utf8220 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8220)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8220)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length223)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result222)))
+					slice225 := ((element).Metadata).Examples
+					length227 := uint32(len(slice225))
+					result226 := witRuntime.Allocate(pinner, uintptr(length227*(2*4)), 4)
+					for index, element := range slice225 {
+						base := unsafe.Add(result226, index*(2*4))
+						utf8224 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8224)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8224)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length227)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result226)))
+
+					switch ((element).Metadata).Deprecated.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Deprecated.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+						utf8228 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8228)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf8228)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Role.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Role.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.RoleMultimodal:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+						case golem_core_types.RoleUnstructuredText:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+						case golem_core_types.RoleUnstructuredBinary:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+						case golem_core_types.RoleOther:
+							payload := payload.Other()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+							utf8229 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8229)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf8229)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length232)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result231)))
+
+			case golem_core_types.SchemaTypeBodyEnumType:
+				payload := (element).Body.EnumType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+				slice234 := payload
+				length236 := uint32(len(slice234))
+				result235 := witRuntime.Allocate(pinner, uintptr(length236*(2*4)), 4)
+				for index, element := range slice234 {
+					base := unsafe.Add(result235, index*(2*4))
+					utf8233 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8233)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8233)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length236)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result235)))
+
+			case golem_core_types.SchemaTypeBodyFlagsType:
+				payload := (element).Body.FlagsType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+				slice238 := payload
+				length240 := uint32(len(slice238))
+				result239 := witRuntime.Allocate(pinner, uintptr(length240*(2*4)), 4)
+				for index, element := range slice238 {
+					base := unsafe.Add(result239, index*(2*4))
+					utf8237 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8237)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8237)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length240)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result239)))
+
+			case golem_core_types.SchemaTypeBodyTupleType:
+				payload := (element).Body.TupleType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+				slice241 := payload
+				length243 := uint32(len(slice241))
+				result242 := witRuntime.Allocate(pinner, uintptr(length243*4), 4)
+				for index, element := range slice241 {
+					base := unsafe.Add(result242, index*4)
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length243)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result242)))
+
+			case golem_core_types.SchemaTypeBodyListType:
+				payload := (element).Body.ListType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+			case golem_core_types.SchemaTypeBodyFixedListType:
+				payload := (element).Body.FixedListType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Element
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Length)
+
+			case golem_core_types.SchemaTypeBodyMapType:
+				payload := (element).Body.MapType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Key
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Value
+
+			case golem_core_types.SchemaTypeBodyOptionType:
+				payload := (element).Body.OptionType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+			case golem_core_types.SchemaTypeBodyResultType:
+				payload := (element).Body.ResultType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+				switch (payload).Ok.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Ok.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Err.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Err.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyTextType:
+				payload := (element).Body.TextType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+				switch (payload).Languages.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Languages.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+					slice245 := payload
+					length247 := uint32(len(slice245))
+					result246 := witRuntime.Allocate(pinner, uintptr(length247*(2*4)), 4)
+					for index, element := range slice245 {
+						base := unsafe.Add(result246, index*(2*4))
+						utf8244 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8244)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8244)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length247)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result246)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).MinLength.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).MinLength.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).MaxLength.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).MaxLength.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Regex.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Regex.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(1))
+					utf8248 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8248)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = uint32(uintptr(uintptr(utf8248)))
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyBinaryType:
+				payload := (element).Body.BinaryType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+
+				switch (payload).MimeTypes.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).MimeTypes.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+					slice250 := payload
+					length252 := uint32(len(slice250))
+					result251 := witRuntime.Allocate(pinner, uintptr(length252*(2*4)), 4)
+					for index, element := range slice250 {
+						base := unsafe.Add(result251, index*(2*4))
+						utf8249 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8249)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8249)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length252)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result251)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).MinBytes.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).MinBytes.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).MaxBytes.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).MaxBytes.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyPathType:
+				payload := (element).Body.PathType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Direction))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Kind))
+
+				switch (payload).AllowedMimeTypes.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).AllowedMimeTypes.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+					slice254 := payload
+					length256 := uint32(len(slice254))
+					result255 := witRuntime.Allocate(pinner, uintptr(length256*(2*4)), 4)
+					for index, element := range slice254 {
+						base := unsafe.Add(result255, index*(2*4))
+						utf8253 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8253)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8253)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length256)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result255)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).AllowedExtensions.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).AllowedExtensions.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+					slice258 := payload
+					length260 := uint32(len(slice258))
+					result259 := witRuntime.Allocate(pinner, uintptr(length260*(2*4)), 4)
+					for index, element := range slice258 {
+						base := unsafe.Add(result259, index*(2*4))
+						utf8257 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8257)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8257)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length260)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result259)))
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyUrlType:
+				payload := (element).Body.UrlType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+
+				switch (payload).AllowedSchemes.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).AllowedSchemes.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+					slice262 := payload
+					length264 := uint32(len(slice262))
+					result263 := witRuntime.Allocate(pinner, uintptr(length264*(2*4)), 4)
+					for index, element := range slice262 {
+						base := unsafe.Add(result263, index*(2*4))
+						utf8261 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8261)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8261)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length264)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result263)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).AllowedHosts.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).AllowedHosts.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+					slice266 := payload
+					length268 := uint32(len(slice266))
+					result267 := witRuntime.Allocate(pinner, uintptr(length268*(2*4)), 4)
+					for index, element := range slice266 {
+						base := unsafe.Add(result267, index*(2*4))
+						utf8265 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8265)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8265)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(length268)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(result267)))
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyDatetimeType:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+			case golem_core_types.SchemaTypeBodyDurationType:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+			case golem_core_types.SchemaTypeBodyQuantityType:
+				payload := (element).Body.QuantityType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+				utf8269 := unsafe.Pointer(unsafe.StringData((payload).BaseUnit))
+				pinner.Pin(utf8269)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).BaseUnit)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8269)))
+				slice271 := (payload).AllowedSuffixes
+				length273 := uint32(len(slice271))
+				result272 := witRuntime.Allocate(pinner, uintptr(length273*(2*4)), 4)
+				for index, element := range slice271 {
+					base := unsafe.Add(result272, index*(2*4))
+					utf8270 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8270)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8270)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length273)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result272)))
+
+				switch (payload).Min.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Min.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))) = (payload).Mantissa
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = (payload).Scale
+					utf8274 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+					pinner.Pin(utf8274)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))) = uint32(uint32(len((payload).Unit)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uintptr(uintptr(utf8274)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (payload).Max.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Max.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(1))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))) = (payload).Mantissa
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))) = (payload).Scale
+					utf8275 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+					pinner.Pin(utf8275)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))) = uint32(uint32(len((payload).Unit)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4))) = uint32(uintptr(uintptr(utf8275)))
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyUnionType:
+				payload := (element).Body.UnionType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+				slice295 := (payload).Branches
+				length297 := uint32(len(slice295))
+				result296 := witRuntime.Allocate(pinner, uintptr(length297*(23*4)), 4)
+				for index, element := range slice295 {
+					base := unsafe.Add(result296, index*(23*4))
+					utf8276 := unsafe.Pointer(unsafe.StringData((element).Tag))
+					pinner.Pin(utf8276)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Tag)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8276)))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+					switch (element).Discriminator.Tag() {
+					case golem_core_types.DiscriminatorRulePrefix:
+						payload := (element).Discriminator.Prefix()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+						utf8277 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8277)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8277)))
+
+					case golem_core_types.DiscriminatorRuleSuffix:
+						payload := (element).Discriminator.Suffix()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+						utf8278 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8278)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8278)))
+
+					case golem_core_types.DiscriminatorRuleContains:
+						payload := (element).Discriminator.Contains()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(2))
+						utf8279 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8279)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8279)))
+
+					case golem_core_types.DiscriminatorRuleRegex:
+						payload := (element).Discriminator.Regex()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(3))
+						utf8280 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8280)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8280)))
+
+					case golem_core_types.DiscriminatorRuleFieldEquals:
+						payload := (element).Discriminator.FieldEquals()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(4))
+						utf8281 := unsafe.Pointer(unsafe.StringData((payload).FieldName))
+						pinner.Pin(utf8281)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((payload).FieldName)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8281)))
+
+						switch (payload).Literal.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Literal.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+							utf8282 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8282)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8282)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.DiscriminatorRuleFieldAbsent:
+						payload := (element).Discriminator.FieldAbsent()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(5))
+						utf8283 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8283)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8283)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Doc.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Doc.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+						utf8284 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8284)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(utf8284)))
+
+					default:
+						panic("unreachable")
+					}
+					slice286 := ((element).Metadata).Aliases
+					length288 := uint32(len(slice286))
+					result287 := witRuntime.Allocate(pinner, uintptr(length288*(2*4)), 4)
+					for index, element := range slice286 {
+						base := unsafe.Add(result287, index*(2*4))
+						utf8285 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8285)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8285)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(length288)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(result287)))
+					slice290 := ((element).Metadata).Examples
+					length292 := uint32(len(slice290))
+					result291 := witRuntime.Allocate(pinner, uintptr(length292*(2*4)), 4)
+					for index, element := range slice290 {
+						base := unsafe.Add(result291, index*(2*4))
+						utf8289 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8289)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8289)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(length292)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(result291)))
+
+					switch ((element).Metadata).Deprecated.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Deprecated.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(1))
+						utf8293 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8293)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf8293)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Role.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Role.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.RoleMultimodal:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(0))
+
+						case golem_core_types.RoleUnstructuredText:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(1))
+
+						case golem_core_types.RoleUnstructuredBinary:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(2))
+
+						case golem_core_types.RoleOther:
+							payload := payload.Other()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(3))
+							utf8294 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8294)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(utf8294)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length297)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result296)))
+
+			case golem_core_types.SchemaTypeBodySecretType:
+				payload := (element).Body.SecretType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Inner
+
+				switch (payload).Category.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).Category.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+					utf8298 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8298)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8298)))
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyQuotaTokenType:
+				payload := (element).Body.QuotaTokenType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+				switch (payload).ResourceName.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).ResourceName.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+					utf8299 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8299)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf8299)))
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyFutureType:
+				payload := (element).Body.FutureType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			case golem_core_types.SchemaTypeBodyStreamType:
+				payload := (element).Body.StreamType()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+				switch payload.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := payload.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+			switch ((element).Metadata).Doc.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := ((element).Metadata).Doc.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(1))
+				utf8300 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8300)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4))) = uint32(uintptr(uintptr(utf8300)))
+
+			default:
+				panic("unreachable")
+			}
+			slice302 := ((element).Metadata).Aliases
+			length304 := uint32(len(slice302))
+			result303 := witRuntime.Allocate(pinner, uintptr(length304*(2*4)), 4)
+			for index, element := range slice302 {
+				base := unsafe.Add(result303, index*(2*4))
+				utf8301 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf8301)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8301)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length304)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result303)))
+			slice306 := ((element).Metadata).Examples
+			length308 := uint32(len(slice306))
+			result307 := witRuntime.Allocate(pinner, uintptr(length308*(2*4)), 4)
+			for index, element := range slice306 {
+				base := unsafe.Add(result307, index*(2*4))
+				utf8305 := unsafe.Pointer(unsafe.StringData(element))
+				pinner.Pin(utf8305)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8305)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length308)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result307)))
+
+			switch ((element).Metadata).Deprecated.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := ((element).Metadata).Deprecated.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(1))
+				utf8309 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8309)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4))) = uint32(uintptr(uintptr(utf8309)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch ((element).Metadata).Role.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := ((element).Metadata).Role.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(1))
+
+				switch payload.Tag() {
+				case golem_core_types.RoleMultimodal:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(0))
+
+				case golem_core_types.RoleUnstructuredText:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(1))
+
+				case golem_core_types.RoleUnstructuredBinary:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(2))
+
+				case golem_core_types.RoleOther:
+					payload := payload.Other()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(3))
+					utf8310 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8310)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4))) = uint32(uintptr(uintptr(utf8310)))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(length313)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uintptr(uintptr(result312)))
+		slice316 := ((element).Schema).Defs
+		length318 := uint32(len(slice316))
+		result317 := witRuntime.Allocate(pinner, uintptr(length318*(6*4)), 4)
+		for index, element := range slice316 {
+			base := unsafe.Add(result317, index*(6*4))
+			utf8314 := unsafe.Pointer(unsafe.StringData((element).Id))
+			pinner.Pin(utf8314)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8314)))
+
+			switch (element).Name.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (element).Name.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+				utf8315 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8315)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8315)))
+
+			default:
+				panic("unreachable")
+			}
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(length318)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(result317)))
+		*(*int32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = ((element).Schema).Root
+
+		switch ((element).Constructor).Name.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Constructor).Name.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(1))
+			utf8319 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8319)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf8319)))
+
+		default:
+			panic("unreachable")
+		}
+		utf8320 := unsafe.Pointer(unsafe.StringData(((element).Constructor).Description))
+		pinner.Pin(utf8320)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uint32(len(((element).Constructor).Description)))
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(uintptr(uintptr(utf8320)))
+
+		switch ((element).Constructor).PromptHint.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := ((element).Constructor).PromptHint.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = int8(int32(1))
+			utf8321 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8321)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uintptr(uintptr(utf8321)))
+
+		default:
+			panic("unreachable")
+		}
+
+		switch ((element).Constructor).InputSchema.Tag() {
+		case golem_agent_common.InputSchemaParameters:
+			payload := ((element).Constructor).InputSchema.Parameters()
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = int8(int32(0))
+			slice334 := payload
+			length336 := uint32(len(slice334))
+			result335 := witRuntime.Allocate(pinner, uintptr(length336*(8+16*4)), 4)
+			for index, element := range slice334 {
+				base := unsafe.Add(result335, index*(8+16*4))
+				utf8322 := unsafe.Pointer(unsafe.StringData((element).Name))
+				pinner.Pin(utf8322)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8322)))
+
+				switch (element).Source.Tag() {
+				case golem_agent_common.FieldSourceUserSupplied:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+				case golem_agent_common.FieldSourceAutoInjected:
+					payload := (element).Source.AutoInjected()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))) = int8(int32(payload))
+
+				default:
+					panic("unreachable")
+				}
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = (element).Schema
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+					utf8323 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8323)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8323)))
+
+				default:
+					panic("unreachable")
+				}
+				slice325 := ((element).Metadata).Aliases
+				length327 := uint32(len(slice325))
+				result326 := witRuntime.Allocate(pinner, uintptr(length327*(2*4)), 4)
+				for index, element := range slice325 {
+					base := unsafe.Add(result326, index*(2*4))
+					utf8324 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8324)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8324)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length327)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result326)))
+				slice329 := ((element).Metadata).Examples
+				length331 := uint32(len(slice329))
+				result330 := witRuntime.Allocate(pinner, uintptr(length331*(2*4)), 4)
+				for index, element := range slice329 {
+					base := unsafe.Add(result330, index*(2*4))
+					utf8328 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8328)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8328)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length331)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result330)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+					utf8332 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8332)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf8332)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+						utf8333 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8333)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf8333)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = uint32(length336)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = uint32(uintptr(uintptr(result335)))
+
+		default:
+			panic("unreachable")
+		}
+		slice381 := (element).Methods
+		length383 := uint32(len(slice381))
+		result382 := witRuntime.Allocate(pinner, uintptr(length383*(40+12*4)), 8)
+		for index, element := range slice381 {
+			base := unsafe.Add(result382, index*(40+12*4))
+			utf8337 := unsafe.Pointer(unsafe.StringData((element).Name))
+			pinner.Pin(utf8337)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8337)))
+			utf8338 := unsafe.Pointer(unsafe.StringData((element).Description))
+			pinner.Pin(utf8338)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).Description)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8338)))
+			slice361 := (element).HttpEndpoint
+			length363 := uint32(len(slice361))
+			result362 := witRuntime.Allocate(pinner, uintptr(length363*(12*4)), 4)
+			for index, element := range slice361 {
+				base := unsafe.Add(result362, index*(12*4))
+
+				switch (element).HttpMethod.Tag() {
+				case golem_agent_common.HttpMethodGet:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+
+				case golem_agent_common.HttpMethodHead:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+				case golem_agent_common.HttpMethodPost:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+				case golem_agent_common.HttpMethodPut:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+				case golem_agent_common.HttpMethodDelete:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+				case golem_agent_common.HttpMethodConnect:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+				case golem_agent_common.HttpMethodOptions:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+				case golem_agent_common.HttpMethodTrace:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+				case golem_agent_common.HttpMethodPatch:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+				case golem_agent_common.HttpMethodCustom:
+					payload := (element).HttpMethod.Custom()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+					utf8339 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8339)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8339)))
+
+				default:
+					panic("unreachable")
+				}
+				slice343 := (element).PathSuffix
+				length345 := uint32(len(slice343))
+				result344 := witRuntime.Allocate(pinner, uintptr(length345*(3*4)), 4)
+				for index, element := range slice343 {
+					base := unsafe.Add(result344, index*(3*4))
+
+					switch element.Tag() {
+					case golem_agent_common.PathSegmentLiteral:
+						payload := element.Literal()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+						utf8340 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8340)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8340)))
+
+					case golem_agent_common.PathSegmentSystemVariable:
+						payload := element.SystemVariable()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 4)) = int8(int32(payload))
+
+					case golem_agent_common.PathSegmentPathVariable:
+						payload := element.PathVariable()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+						utf8341 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+						pinner.Pin(utf8341)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8341)))
+
+					case golem_agent_common.PathSegmentRemainingPathVariable:
+						payload := element.RemainingPathVariable()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+						utf8342 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+						pinner.Pin(utf8342)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8342)))
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(length345)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(result344)))
+				slice348 := (element).HeaderVars
+				length350 := uint32(len(slice348))
+				result349 := witRuntime.Allocate(pinner, uintptr(length350*(4*4)), 4)
+				for index, element := range slice348 {
+					base := unsafe.Add(result349, index*(4*4))
+					utf8346 := unsafe.Pointer(unsafe.StringData((element).HeaderName))
+					pinner.Pin(utf8346)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).HeaderName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8346)))
+					utf8347 := unsafe.Pointer(unsafe.StringData((element).VariableName))
+					pinner.Pin(utf8347)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8347)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(length350)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uintptr(uintptr(result349)))
+				slice353 := (element).QueryVars
+				length355 := uint32(len(slice353))
+				result354 := witRuntime.Allocate(pinner, uintptr(length355*(4*4)), 4)
+				for index, element := range slice353 {
+					base := unsafe.Add(result354, index*(4*4))
+					utf8351 := unsafe.Pointer(unsafe.StringData((element).QueryParamName))
+					pinner.Pin(utf8351)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).QueryParamName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8351)))
+					utf8352 := unsafe.Pointer(unsafe.StringData((element).VariableName))
+					pinner.Pin(utf8352)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8352)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(length355)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(result354)))
+
+				switch (element).AuthDetails.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (element).AuthDetails.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+					var result356 int32
+					if (payload).Required {
+						result356 = 1
+					} else {
+						result356 = 0
+					}
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 9*4))) = int8(result356)
+
+				default:
+					panic("unreachable")
+				}
+				slice358 := ((element).CorsOptions).AllowedPatterns
+				length360 := uint32(len(slice358))
+				result359 := witRuntime.Allocate(pinner, uintptr(length360*(2*4)), 4)
+				for index, element := range slice358 {
+					base := unsafe.Add(result359, index*(2*4))
+					utf8357 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8357)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8357)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length360)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result359)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(length363)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(result362)))
+
+			switch (element).PromptHint.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (element).PromptHint.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+				utf8364 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8364)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8364)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (element).InputSchema.Tag() {
+			case golem_agent_common.InputSchemaParameters:
+				payload := (element).InputSchema.Parameters()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+				slice377 := payload
+				length379 := uint32(len(slice377))
+				result378 := witRuntime.Allocate(pinner, uintptr(length379*(8+16*4)), 4)
+				for index, element := range slice377 {
+					base := unsafe.Add(result378, index*(8+16*4))
+					utf8365 := unsafe.Pointer(unsafe.StringData((element).Name))
+					pinner.Pin(utf8365)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8365)))
+
+					switch (element).Source.Tag() {
+					case golem_agent_common.FieldSourceUserSupplied:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+					case golem_agent_common.FieldSourceAutoInjected:
+						payload := (element).Source.AutoInjected()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))) = int8(int32(payload))
+
+					default:
+						panic("unreachable")
+					}
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = (element).Schema
+
+					switch ((element).Metadata).Doc.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Doc.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						utf8366 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8366)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8366)))
+
+					default:
+						panic("unreachable")
+					}
+					slice368 := ((element).Metadata).Aliases
+					length370 := uint32(len(slice368))
+					result369 := witRuntime.Allocate(pinner, uintptr(length370*(2*4)), 4)
+					for index, element := range slice368 {
+						base := unsafe.Add(result369, index*(2*4))
+						utf8367 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8367)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8367)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length370)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result369)))
+					slice372 := ((element).Metadata).Examples
+					length374 := uint32(len(slice372))
+					result373 := witRuntime.Allocate(pinner, uintptr(length374*(2*4)), 4)
+					for index, element := range slice372 {
+						base := unsafe.Add(result373, index*(2*4))
+						utf8371 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8371)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8371)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length374)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result373)))
+
+					switch ((element).Metadata).Deprecated.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Deprecated.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+						utf8375 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8375)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf8375)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Role.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Role.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.RoleMultimodal:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+						case golem_core_types.RoleUnstructuredText:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+						case golem_core_types.RoleUnstructuredBinary:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+						case golem_core_types.RoleOther:
+							payload := payload.Other()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+							utf8376 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8376)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf8376)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length379)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result378)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (element).OutputSchema.Tag() {
+			case golem_agent_common.OutputSchemaUnit:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = int8(int32(0))
+
+			case golem_agent_common.OutputSchemaSingle:
+				payload := (element).OutputSchema.Single()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = int8(int32(1))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 12*4))) = payload
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (element).ReadOnly.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (element).ReadOnly.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+				switch (payload).CachePolicy.Tag() {
+				case golem_agent_common.CachePolicyNoCache:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4))) = int8(int32(0))
+
+				case golem_agent_common.CachePolicyUntilWrite:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4))) = int8(int32(1))
+
+				case golem_agent_common.CachePolicyTtl:
+					payload := (payload).CachePolicy.Ttl()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4))) = int8(int32(2))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 12*4))) = int64(payload)
+
+				default:
+					panic("unreachable")
+				}
+				var result380 int32
+				if (payload).UsesPrincipal {
+					result380 = 1
+				} else {
+					result380 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))) = int8(result380)
+
+			default:
+				panic("unreachable")
+			}
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(length383)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(result382)))
+
+	}
+
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (25 * 4))) = uint32(length386)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (24 * 4))) = uint32(uintptr(uintptr(result385)))
+	*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (26 * 4))) = int8(int32((result).Mode))
+
+	switch (result).HttpMount.Tag() {
+	case witTypes.OptionNone:
+		*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (27 * 4))) = int8(int32(0))
+
+	case witTypes.OptionSome:
+		payload := (result).HttpMount.Some()
+		*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (27 * 4))) = int8(int32(1))
+		slice390 := (payload).PathPrefix
+		length392 := uint32(len(slice390))
+		result391 := witRuntime.Allocate(pinner, uintptr(length392*(3*4)), 4)
+		for index, element := range slice390 {
+			base := unsafe.Add(result391, index*(3*4))
+
+			switch element.Tag() {
+			case golem_agent_common.PathSegmentLiteral:
+				payload := element.Literal()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+				utf8387 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8387)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8387)))
+
+			case golem_agent_common.PathSegmentSystemVariable:
+				payload := element.SystemVariable()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 4)) = int8(int32(payload))
+
+			case golem_agent_common.PathSegmentPathVariable:
+				payload := element.PathVariable()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+				utf8388 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+				pinner.Pin(utf8388)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8388)))
+
+			case golem_agent_common.PathSegmentRemainingPathVariable:
+				payload := element.RemainingPathVariable()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+				utf8389 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+				pinner.Pin(utf8389)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8389)))
+
+			default:
+				panic("unreachable")
+			}
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (29 * 4))) = uint32(length392)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (28 * 4))) = uint32(uintptr(uintptr(result391)))
+
+		switch (payload).AuthDetails.Tag() {
+		case witTypes.OptionNone:
+			*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (30 * 4))) = int8(int32(0))
+
+		case witTypes.OptionSome:
+			payload := (payload).AuthDetails.Some()
+			*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (30 * 4))) = int8(int32(1))
+			var result393 int32
+			if (payload).Required {
+				result393 = 1
+			} else {
+				result393 = 0
+			}
+			*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (1 + 30*4))) = int8(result393)
+
+		default:
+			panic("unreachable")
+		}
+		var result394 int32
+		if (payload).PhantomAgent {
+			result394 = 1
+		} else {
+			result394 = 0
+		}
+		*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (2 + 30*4))) = int8(result394)
+		slice396 := ((payload).CorsOptions).AllowedPatterns
+		length398 := uint32(len(slice396))
+		result397 := witRuntime.Allocate(pinner, uintptr(length398*(2*4)), 4)
+		for index, element := range slice396 {
+			base := unsafe.Add(result397, index*(2*4))
+			utf8395 := unsafe.Pointer(unsafe.StringData(element))
+			pinner.Pin(utf8395)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8395)))
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (32 * 4))) = uint32(length398)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (31 * 4))) = uint32(uintptr(uintptr(result397)))
+		slice402 := (payload).WebhookSuffix
+		length404 := uint32(len(slice402))
+		result403 := witRuntime.Allocate(pinner, uintptr(length404*(3*4)), 4)
+		for index, element := range slice402 {
+			base := unsafe.Add(result403, index*(3*4))
+
+			switch element.Tag() {
+			case golem_agent_common.PathSegmentLiteral:
+				payload := element.Literal()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+				utf8399 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8399)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8399)))
+
+			case golem_agent_common.PathSegmentSystemVariable:
+				payload := element.SystemVariable()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 4)) = int8(int32(payload))
+
+			case golem_agent_common.PathSegmentPathVariable:
+				payload := element.PathVariable()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+				utf8400 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+				pinner.Pin(utf8400)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8400)))
+
+			case golem_agent_common.PathSegmentRemainingPathVariable:
+				payload := element.RemainingPathVariable()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+				utf8401 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+				pinner.Pin(utf8401)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8401)))
+
+			default:
+				panic("unreachable")
+			}
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (34 * 4))) = uint32(length404)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (33 * 4))) = uint32(uintptr(uintptr(result403)))
+
+	default:
+		panic("unreachable")
+	}
+
+	switch (result).Snapshotting.Tag() {
+	case golem_agent_common.SnapshottingDisabled:
+
+		*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (8 + 34*4))) = int8(int32(0))
+
+	case golem_agent_common.SnapshottingEnabled:
+		payload := (result).Snapshotting.Enabled()
+		*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (8 + 34*4))) = int8(int32(1))
+
+		switch payload.Tag() {
+		case golem_agent_common.SnapshottingConfigDefault:
+
+			*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (16 + 34*4))) = int8(int32(0))
+
+		case golem_agent_common.SnapshottingConfigPeriodic:
+			payload := payload.Periodic()
+			*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (16 + 34*4))) = int8(int32(1))
+			*(*int64)(unsafe.Add(unsafe.Pointer(exportReturnArea), (24 + 34*4))) = int64(payload)
+
+		case golem_agent_common.SnapshottingConfigEveryNInvocation:
+			payload := payload.EveryNInvocation()
+			*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (16 + 34*4))) = int8(int32(2))
+			*(*int16)(unsafe.Add(unsafe.Pointer(exportReturnArea), (24 + 34*4))) = int16(int32(payload))
+
+		default:
+			panic("unreachable")
+		}
+
+	default:
+		panic("unreachable")
+	}
+	slice409 := (result).Config
+	length411 := uint32(len(slice409))
+	result410 := witRuntime.Allocate(pinner, uintptr(length411*(4*4)), 4)
+	for index, element := range slice409 {
+		base := unsafe.Add(result410, index*(4*4))
+		*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32((element).Source))
+		slice406 := (element).Path
+		length408 := uint32(len(slice406))
+		result407 := witRuntime.Allocate(pinner, uintptr(length408*(2*4)), 4)
+		for index, element := range slice406 {
+			base := unsafe.Add(result407, index*(2*4))
+			utf8405 := unsafe.Pointer(unsafe.StringData(element))
+			pinner.Pin(utf8405)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8405)))
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(length408)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(result407)))
+		*(*int32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = (element).ValueType
+
+	}
+
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (32 + 35*4))) = uint32(length411)
+	*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (32 + 34*4))) = uint32(uintptr(uintptr(result410)))
+	return exportReturnArea
+
+}
+
+//go:wasmexport cabi_post_golem:agent/guest@2.0.0#get-definition
+func wasm_export_post_return_golem_agent_guest_get_definition(result uintptr) {
+	syncExportPinner.Unpin()
+}
+
+//go:wasmexport golem:agent/guest@2.0.0#discover-agent-types
+func wasm_export_golem_agent_guest_discover_agent_types() uintptr {
+
+	pinner := &syncExportPinner
+	result := export_golem_agent_guest.DiscoverAgentTypes()
+
+	switch result.Tag() {
+	case witTypes.ResultOk:
+		payload := result.Ok()
+		*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), 0)) = int8(int32(0))
+		slice412 := payload
+		length414 := uint32(len(slice412))
+		result413 := witRuntime.Allocate(pinner, uintptr(length414*(32+36*4)), 8)
+		for index, element := range slice412 {
+			base := unsafe.Add(result413, index*(32+36*4))
+			utf8 := unsafe.Pointer(unsafe.StringData((element).TypeName))
+			pinner.Pin(utf8)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).TypeName)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8)))
+			utf80 := unsafe.Pointer(unsafe.StringData((element).Description))
+			pinner.Pin(utf80)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).Description)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf80)))
+			utf81 := unsafe.Pointer(unsafe.StringData((element).SourceLanguage))
+			pinner.Pin(utf81)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((element).SourceLanguage)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf81)))
+			slice118 := ((element).Schema).TypeNodes
+			length120 := uint32(len(slice118))
+			result119 := witRuntime.Allocate(pinner, uintptr(length120*(56+22*4)), 8)
+			for index, element := range slice118 {
+				base := unsafe.Add(result119, index*(56+22*4))
+
+				switch (element).Body.Tag() {
+				case golem_core_types.SchemaTypeBodyRefType:
+					payload := (element).Body.RefType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+				case golem_core_types.SchemaTypeBodyBoolType:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+				case golem_core_types.SchemaTypeBodyS8Type:
+					payload := (element).Body.S8Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf82 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf82)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf82)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyS16Type:
+					payload := (element).Body.S16Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf83 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf83)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf83)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyS32Type:
+					payload := (element).Body.S32Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf84 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf84)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf84)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyS64Type:
+					payload := (element).Body.S64Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf85 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf85)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf85)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyU8Type:
+					payload := (element).Body.U8Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf86 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf86)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf86)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyU16Type:
+					payload := (element).Body.U16Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf87 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf87)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf87)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyU32Type:
+					payload := (element).Body.U32Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf88 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf88)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf88)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyU64Type:
+					payload := (element).Body.U64Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf89 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf89)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf89)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyF32Type:
+					payload := (element).Body.F32Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf810 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf810)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf810)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyF64Type:
+					payload := (element).Body.F64Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf811 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf811)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf811)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyCharType:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+
+				case golem_core_types.SchemaTypeBodyStringType:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+
+				case golem_core_types.SchemaTypeBodyRecordType:
+					payload := (element).Body.RecordType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+					slice22 := payload
+					length24 := uint32(len(slice22))
+					result23 := witRuntime.Allocate(pinner, uintptr(length24*(17*4)), 4)
+					for index, element := range slice22 {
+						base := unsafe.Add(result23, index*(17*4))
+						utf812 := unsafe.Pointer(unsafe.StringData((element).Name))
+						pinner.Pin(utf812)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf812)))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+						switch ((element).Metadata).Doc.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Doc.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+							utf813 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf813)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf813)))
+
+						default:
+							panic("unreachable")
+						}
+						slice := ((element).Metadata).Aliases
+						length := uint32(len(slice))
+						result15 := witRuntime.Allocate(pinner, uintptr(length*(2*4)), 4)
+						for index, element := range slice {
+							base := unsafe.Add(result15, index*(2*4))
+							utf814 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf814)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf814)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result15)))
+						slice17 := ((element).Metadata).Examples
+						length19 := uint32(len(slice17))
+						result18 := witRuntime.Allocate(pinner, uintptr(length19*(2*4)), 4)
+						for index, element := range slice17 {
+							base := unsafe.Add(result18, index*(2*4))
+							utf816 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf816)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf816)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = uint32(length19)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result18)))
+
+						switch ((element).Metadata).Deprecated.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Deprecated.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(1))
+							utf820 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf820)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf820)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch ((element).Metadata).Role.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Role.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.RoleMultimodal:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(0))
+
+							case golem_core_types.RoleUnstructuredText:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(1))
+
+							case golem_core_types.RoleUnstructuredBinary:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(2))
+
+							case golem_core_types.RoleOther:
+								payload := payload.Other()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(3))
+								utf821 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf821)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uintptr(uintptr(utf821)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length24)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result23)))
+
+				case golem_core_types.SchemaTypeBodyVariantType:
+					payload := (element).Body.VariantType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+					slice37 := payload
+					length39 := uint32(len(slice37))
+					result38 := witRuntime.Allocate(pinner, uintptr(length39*(8+16*4)), 4)
+					for index, element := range slice37 {
+						base := unsafe.Add(result38, index*(8+16*4))
+						utf825 := unsafe.Pointer(unsafe.StringData((element).Name))
+						pinner.Pin(utf825)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf825)))
+
+						switch (element).Payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (element).Payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+						switch ((element).Metadata).Doc.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Doc.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+							utf826 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf826)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf826)))
+
+						default:
+							panic("unreachable")
+						}
+						slice28 := ((element).Metadata).Aliases
+						length30 := uint32(len(slice28))
+						result29 := witRuntime.Allocate(pinner, uintptr(length30*(2*4)), 4)
+						for index, element := range slice28 {
+							base := unsafe.Add(result29, index*(2*4))
+							utf827 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf827)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf827)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length30)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result29)))
+						slice32 := ((element).Metadata).Examples
+						length34 := uint32(len(slice32))
+						result33 := witRuntime.Allocate(pinner, uintptr(length34*(2*4)), 4)
+						for index, element := range slice32 {
+							base := unsafe.Add(result33, index*(2*4))
+							utf831 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf831)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf831)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length34)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result33)))
+
+						switch ((element).Metadata).Deprecated.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Deprecated.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+							utf835 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf835)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf835)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch ((element).Metadata).Role.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Role.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.RoleMultimodal:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+							case golem_core_types.RoleUnstructuredText:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+							case golem_core_types.RoleUnstructuredBinary:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+							case golem_core_types.RoleOther:
+								payload := payload.Other()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+								utf836 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf836)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf836)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length39)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result38)))
+
+				case golem_core_types.SchemaTypeBodyEnumType:
+					payload := (element).Body.EnumType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+					slice41 := payload
+					length43 := uint32(len(slice41))
+					result42 := witRuntime.Allocate(pinner, uintptr(length43*(2*4)), 4)
+					for index, element := range slice41 {
+						base := unsafe.Add(result42, index*(2*4))
+						utf840 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf840)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf840)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length43)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result42)))
+
+				case golem_core_types.SchemaTypeBodyFlagsType:
+					payload := (element).Body.FlagsType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+					slice45 := payload
+					length47 := uint32(len(slice45))
+					result46 := witRuntime.Allocate(pinner, uintptr(length47*(2*4)), 4)
+					for index, element := range slice45 {
+						base := unsafe.Add(result46, index*(2*4))
+						utf844 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf844)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf844)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length47)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result46)))
+
+				case golem_core_types.SchemaTypeBodyTupleType:
+					payload := (element).Body.TupleType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+					slice48 := payload
+					length50 := uint32(len(slice48))
+					result49 := witRuntime.Allocate(pinner, uintptr(length50*4), 4)
+					for index, element := range slice48 {
+						base := unsafe.Add(result49, index*4)
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length50)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result49)))
+
+				case golem_core_types.SchemaTypeBodyListType:
+					payload := (element).Body.ListType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+				case golem_core_types.SchemaTypeBodyFixedListType:
+					payload := (element).Body.FixedListType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Element
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Length)
+
+				case golem_core_types.SchemaTypeBodyMapType:
+					payload := (element).Body.MapType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Key
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Value
+
+				case golem_core_types.SchemaTypeBodyOptionType:
+					payload := (element).Body.OptionType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+				case golem_core_types.SchemaTypeBodyResultType:
+					payload := (element).Body.ResultType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+					switch (payload).Ok.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Ok.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Err.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Err.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyTextType:
+					payload := (element).Body.TextType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+					switch (payload).Languages.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Languages.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+						slice52 := payload
+						length54 := uint32(len(slice52))
+						result53 := witRuntime.Allocate(pinner, uintptr(length54*(2*4)), 4)
+						for index, element := range slice52 {
+							base := unsafe.Add(result53, index*(2*4))
+							utf851 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf851)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf851)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length54)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result53)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).MinLength.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).MinLength.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).MaxLength.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).MaxLength.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Regex.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Regex.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(1))
+						utf855 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf855)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = uint32(uintptr(uintptr(utf855)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyBinaryType:
+					payload := (element).Body.BinaryType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+
+					switch (payload).MimeTypes.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).MimeTypes.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+						slice57 := payload
+						length59 := uint32(len(slice57))
+						result58 := witRuntime.Allocate(pinner, uintptr(length59*(2*4)), 4)
+						for index, element := range slice57 {
+							base := unsafe.Add(result58, index*(2*4))
+							utf856 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf856)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf856)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length59)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result58)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).MinBytes.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).MinBytes.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).MaxBytes.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).MaxBytes.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyPathType:
+					payload := (element).Body.PathType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Direction))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Kind))
+
+					switch (payload).AllowedMimeTypes.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).AllowedMimeTypes.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+						slice61 := payload
+						length63 := uint32(len(slice61))
+						result62 := witRuntime.Allocate(pinner, uintptr(length63*(2*4)), 4)
+						for index, element := range slice61 {
+							base := unsafe.Add(result62, index*(2*4))
+							utf860 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf860)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf860)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length63)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result62)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).AllowedExtensions.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).AllowedExtensions.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+						slice65 := payload
+						length67 := uint32(len(slice65))
+						result66 := witRuntime.Allocate(pinner, uintptr(length67*(2*4)), 4)
+						for index, element := range slice65 {
+							base := unsafe.Add(result66, index*(2*4))
+							utf864 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf864)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf864)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length67)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result66)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyUrlType:
+					payload := (element).Body.UrlType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+
+					switch (payload).AllowedSchemes.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).AllowedSchemes.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+						slice69 := payload
+						length71 := uint32(len(slice69))
+						result70 := witRuntime.Allocate(pinner, uintptr(length71*(2*4)), 4)
+						for index, element := range slice69 {
+							base := unsafe.Add(result70, index*(2*4))
+							utf868 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf868)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf868)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length71)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result70)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).AllowedHosts.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).AllowedHosts.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+						slice73 := payload
+						length75 := uint32(len(slice73))
+						result74 := witRuntime.Allocate(pinner, uintptr(length75*(2*4)), 4)
+						for index, element := range slice73 {
+							base := unsafe.Add(result74, index*(2*4))
+							utf872 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf872)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf872)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(length75)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(result74)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyDatetimeType:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+				case golem_core_types.SchemaTypeBodyDurationType:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+				case golem_core_types.SchemaTypeBodyQuantityType:
+					payload := (element).Body.QuantityType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+					utf876 := unsafe.Pointer(unsafe.StringData((payload).BaseUnit))
+					pinner.Pin(utf876)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).BaseUnit)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf876)))
+					slice78 := (payload).AllowedSuffixes
+					length80 := uint32(len(slice78))
+					result79 := witRuntime.Allocate(pinner, uintptr(length80*(2*4)), 4)
+					for index, element := range slice78 {
+						base := unsafe.Add(result79, index*(2*4))
+						utf877 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf877)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf877)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length80)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result79)))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))) = (payload).Mantissa
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = (payload).Scale
+						utf881 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+						pinner.Pin(utf881)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))) = uint32(uint32(len((payload).Unit)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uintptr(uintptr(utf881)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))) = (payload).Mantissa
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))) = (payload).Scale
+						utf882 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+						pinner.Pin(utf882)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))) = uint32(uint32(len((payload).Unit)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4))) = uint32(uintptr(uintptr(utf882)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyUnionType:
+					payload := (element).Body.UnionType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+					slice102 := (payload).Branches
+					length104 := uint32(len(slice102))
+					result103 := witRuntime.Allocate(pinner, uintptr(length104*(23*4)), 4)
+					for index, element := range slice102 {
+						base := unsafe.Add(result103, index*(23*4))
+						utf883 := unsafe.Pointer(unsafe.StringData((element).Tag))
+						pinner.Pin(utf883)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Tag)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf883)))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+						switch (element).Discriminator.Tag() {
+						case golem_core_types.DiscriminatorRulePrefix:
+							payload := (element).Discriminator.Prefix()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+							utf884 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf884)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf884)))
+
+						case golem_core_types.DiscriminatorRuleSuffix:
+							payload := (element).Discriminator.Suffix()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+							utf885 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf885)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf885)))
+
+						case golem_core_types.DiscriminatorRuleContains:
+							payload := (element).Discriminator.Contains()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(2))
+							utf886 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf886)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf886)))
+
+						case golem_core_types.DiscriminatorRuleRegex:
+							payload := (element).Discriminator.Regex()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(3))
+							utf887 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf887)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf887)))
+
+						case golem_core_types.DiscriminatorRuleFieldEquals:
+							payload := (element).Discriminator.FieldEquals()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(4))
+							utf888 := unsafe.Pointer(unsafe.StringData((payload).FieldName))
+							pinner.Pin(utf888)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((payload).FieldName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf888)))
+
+							switch (payload).Literal.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Literal.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+								utf889 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf889)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf889)))
+
+							default:
+								panic("unreachable")
+							}
+
+						case golem_core_types.DiscriminatorRuleFieldAbsent:
+							payload := (element).Discriminator.FieldAbsent()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(5))
+							utf890 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf890)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf890)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch ((element).Metadata).Doc.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Doc.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+							utf891 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf891)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(utf891)))
+
+						default:
+							panic("unreachable")
+						}
+						slice93 := ((element).Metadata).Aliases
+						length95 := uint32(len(slice93))
+						result94 := witRuntime.Allocate(pinner, uintptr(length95*(2*4)), 4)
+						for index, element := range slice93 {
+							base := unsafe.Add(result94, index*(2*4))
+							utf892 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf892)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf892)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(length95)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(result94)))
+						slice97 := ((element).Metadata).Examples
+						length99 := uint32(len(slice97))
+						result98 := witRuntime.Allocate(pinner, uintptr(length99*(2*4)), 4)
+						for index, element := range slice97 {
+							base := unsafe.Add(result98, index*(2*4))
+							utf896 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf896)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf896)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(length99)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(result98)))
+
+						switch ((element).Metadata).Deprecated.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Deprecated.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(1))
+							utf8100 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8100)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf8100)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch ((element).Metadata).Role.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Role.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.RoleMultimodal:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(0))
+
+							case golem_core_types.RoleUnstructuredText:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(1))
+
+							case golem_core_types.RoleUnstructuredBinary:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(2))
+
+							case golem_core_types.RoleOther:
+								payload := payload.Other()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(3))
+								utf8101 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8101)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(utf8101)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length104)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result103)))
+
+				case golem_core_types.SchemaTypeBodySecretType:
+					payload := (element).Body.SecretType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Inner
+
+					switch (payload).Category.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Category.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+						utf8105 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8105)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8105)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyQuotaTokenType:
+					payload := (element).Body.QuotaTokenType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+					switch (payload).ResourceName.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).ResourceName.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+						utf8106 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8106)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf8106)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyFutureType:
+					payload := (element).Body.FutureType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyStreamType:
+					payload := (element).Body.StreamType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(1))
+					utf8107 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8107)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4))) = uint32(uintptr(uintptr(utf8107)))
+
+				default:
+					panic("unreachable")
+				}
+				slice109 := ((element).Metadata).Aliases
+				length111 := uint32(len(slice109))
+				result110 := witRuntime.Allocate(pinner, uintptr(length111*(2*4)), 4)
+				for index, element := range slice109 {
+					base := unsafe.Add(result110, index*(2*4))
+					utf8108 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8108)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8108)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length111)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result110)))
+				slice113 := ((element).Metadata).Examples
+				length115 := uint32(len(slice113))
+				result114 := witRuntime.Allocate(pinner, uintptr(length115*(2*4)), 4)
+				for index, element := range slice113 {
+					base := unsafe.Add(result114, index*(2*4))
+					utf8112 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8112)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8112)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length115)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result114)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(1))
+					utf8116 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8116)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4))) = uint32(uintptr(uintptr(utf8116)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(3))
+						utf8117 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8117)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4))) = uint32(uintptr(uintptr(utf8117)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length120)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result119)))
+			slice123 := ((element).Schema).Defs
+			length125 := uint32(len(slice123))
+			result124 := witRuntime.Allocate(pinner, uintptr(length125*(6*4)), 4)
+			for index, element := range slice123 {
+				base := unsafe.Add(result124, index*(6*4))
+				utf8121 := unsafe.Pointer(unsafe.StringData((element).Id))
+				pinner.Pin(utf8121)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8121)))
+
+				switch (element).Name.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (element).Name.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+					utf8122 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8122)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8122)))
+
+				default:
+					panic("unreachable")
+				}
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = uint32(length125)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result124)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = ((element).Schema).Root
+
+			switch ((element).Constructor).Name.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := ((element).Constructor).Name.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = int8(int32(1))
+				utf8126 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8126)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(utf8126)))
+
+			default:
+				panic("unreachable")
+			}
+			utf8127 := unsafe.Pointer(unsafe.StringData(((element).Constructor).Description))
+			pinner.Pin(utf8127)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uint32(len(((element).Constructor).Description)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(utf8127)))
+
+			switch ((element).Constructor).PromptHint.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := ((element).Constructor).PromptHint.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(1))
+				utf8128 := unsafe.Pointer(unsafe.StringData(payload))
+				pinner.Pin(utf8128)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf8128)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch ((element).Constructor).InputSchema.Tag() {
+			case golem_agent_common.InputSchemaParameters:
+				payload := ((element).Constructor).InputSchema.Parameters()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(0))
+				slice141 := payload
+				length143 := uint32(len(slice141))
+				result142 := witRuntime.Allocate(pinner, uintptr(length143*(8+16*4)), 4)
+				for index, element := range slice141 {
+					base := unsafe.Add(result142, index*(8+16*4))
+					utf8129 := unsafe.Pointer(unsafe.StringData((element).Name))
+					pinner.Pin(utf8129)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8129)))
+
+					switch (element).Source.Tag() {
+					case golem_agent_common.FieldSourceUserSupplied:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+					case golem_agent_common.FieldSourceAutoInjected:
+						payload := (element).Source.AutoInjected()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))) = int8(int32(payload))
+
+					default:
+						panic("unreachable")
+					}
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = (element).Schema
+
+					switch ((element).Metadata).Doc.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Doc.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						utf8130 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8130)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8130)))
+
+					default:
+						panic("unreachable")
+					}
+					slice132 := ((element).Metadata).Aliases
+					length134 := uint32(len(slice132))
+					result133 := witRuntime.Allocate(pinner, uintptr(length134*(2*4)), 4)
+					for index, element := range slice132 {
+						base := unsafe.Add(result133, index*(2*4))
+						utf8131 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8131)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8131)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length134)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result133)))
+					slice136 := ((element).Metadata).Examples
+					length138 := uint32(len(slice136))
+					result137 := witRuntime.Allocate(pinner, uintptr(length138*(2*4)), 4)
+					for index, element := range slice136 {
+						base := unsafe.Add(result137, index*(2*4))
+						utf8135 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8135)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8135)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length138)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result137)))
+
+					switch ((element).Metadata).Deprecated.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Deprecated.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+						utf8139 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8139)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf8139)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Role.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Role.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.RoleMultimodal:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+						case golem_core_types.RoleUnstructuredText:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+						case golem_core_types.RoleUnstructuredBinary:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+						case golem_core_types.RoleOther:
+							payload := payload.Other()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+							utf8140 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8140)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf8140)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(length143)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = uint32(uintptr(uintptr(result142)))
+
+			default:
+				panic("unreachable")
+			}
+			slice188 := (element).Methods
+			length190 := uint32(len(slice188))
+			result189 := witRuntime.Allocate(pinner, uintptr(length190*(40+12*4)), 8)
+			for index, element := range slice188 {
+				base := unsafe.Add(result189, index*(40+12*4))
+				utf8144 := unsafe.Pointer(unsafe.StringData((element).Name))
+				pinner.Pin(utf8144)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8144)))
+				utf8145 := unsafe.Pointer(unsafe.StringData((element).Description))
+				pinner.Pin(utf8145)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).Description)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8145)))
+				slice168 := (element).HttpEndpoint
+				length170 := uint32(len(slice168))
+				result169 := witRuntime.Allocate(pinner, uintptr(length170*(12*4)), 4)
+				for index, element := range slice168 {
+					base := unsafe.Add(result169, index*(12*4))
+
+					switch (element).HttpMethod.Tag() {
+					case golem_agent_common.HttpMethodGet:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+
+					case golem_agent_common.HttpMethodHead:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+					case golem_agent_common.HttpMethodPost:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+					case golem_agent_common.HttpMethodPut:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+					case golem_agent_common.HttpMethodDelete:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+					case golem_agent_common.HttpMethodConnect:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+					case golem_agent_common.HttpMethodOptions:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+					case golem_agent_common.HttpMethodTrace:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+					case golem_agent_common.HttpMethodPatch:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+					case golem_agent_common.HttpMethodCustom:
+						payload := (element).HttpMethod.Custom()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+						utf8146 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8146)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8146)))
+
+					default:
+						panic("unreachable")
+					}
+					slice150 := (element).PathSuffix
+					length152 := uint32(len(slice150))
+					result151 := witRuntime.Allocate(pinner, uintptr(length152*(3*4)), 4)
+					for index, element := range slice150 {
+						base := unsafe.Add(result151, index*(3*4))
+
+						switch element.Tag() {
+						case golem_agent_common.PathSegmentLiteral:
+							payload := element.Literal()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+							utf8147 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8147)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8147)))
+
+						case golem_agent_common.PathSegmentSystemVariable:
+							payload := element.SystemVariable()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 4)) = int8(int32(payload))
+
+						case golem_agent_common.PathSegmentPathVariable:
+							payload := element.PathVariable()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+							utf8148 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+							pinner.Pin(utf8148)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8148)))
+
+						case golem_agent_common.PathSegmentRemainingPathVariable:
+							payload := element.RemainingPathVariable()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+							utf8149 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+							pinner.Pin(utf8149)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8149)))
+
+						default:
+							panic("unreachable")
+						}
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(length152)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(result151)))
+					slice155 := (element).HeaderVars
+					length157 := uint32(len(slice155))
+					result156 := witRuntime.Allocate(pinner, uintptr(length157*(4*4)), 4)
+					for index, element := range slice155 {
+						base := unsafe.Add(result156, index*(4*4))
+						utf8153 := unsafe.Pointer(unsafe.StringData((element).HeaderName))
+						pinner.Pin(utf8153)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).HeaderName)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8153)))
+						utf8154 := unsafe.Pointer(unsafe.StringData((element).VariableName))
+						pinner.Pin(utf8154)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8154)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(length157)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uintptr(uintptr(result156)))
+					slice160 := (element).QueryVars
+					length162 := uint32(len(slice160))
+					result161 := witRuntime.Allocate(pinner, uintptr(length162*(4*4)), 4)
+					for index, element := range slice160 {
+						base := unsafe.Add(result161, index*(4*4))
+						utf8158 := unsafe.Pointer(unsafe.StringData((element).QueryParamName))
+						pinner.Pin(utf8158)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).QueryParamName)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8158)))
+						utf8159 := unsafe.Pointer(unsafe.StringData((element).VariableName))
+						pinner.Pin(utf8159)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8159)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(length162)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(result161)))
+
+					switch (element).AuthDetails.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (element).AuthDetails.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+						var result163 int32
+						if (payload).Required {
+							result163 = 1
+						} else {
+							result163 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 9*4))) = int8(result163)
+
+					default:
+						panic("unreachable")
+					}
+					slice165 := ((element).CorsOptions).AllowedPatterns
+					length167 := uint32(len(slice165))
+					result166 := witRuntime.Allocate(pinner, uintptr(length167*(2*4)), 4)
+					for index, element := range slice165 {
+						base := unsafe.Add(result166, index*(2*4))
+						utf8164 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8164)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8164)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length167)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result166)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(length170)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(result169)))
+
+				switch (element).PromptHint.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (element).PromptHint.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+					utf8171 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8171)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8171)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (element).InputSchema.Tag() {
+				case golem_agent_common.InputSchemaParameters:
+					payload := (element).InputSchema.Parameters()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+					slice184 := payload
+					length186 := uint32(len(slice184))
+					result185 := witRuntime.Allocate(pinner, uintptr(length186*(8+16*4)), 4)
+					for index, element := range slice184 {
+						base := unsafe.Add(result185, index*(8+16*4))
+						utf8172 := unsafe.Pointer(unsafe.StringData((element).Name))
+						pinner.Pin(utf8172)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8172)))
+
+						switch (element).Source.Tag() {
+						case golem_agent_common.FieldSourceUserSupplied:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+						case golem_agent_common.FieldSourceAutoInjected:
+							payload := (element).Source.AutoInjected()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))) = int8(int32(payload))
+
+						default:
+							panic("unreachable")
+						}
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = (element).Schema
+
+						switch ((element).Metadata).Doc.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Doc.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+							utf8173 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8173)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8173)))
+
+						default:
+							panic("unreachable")
+						}
+						slice175 := ((element).Metadata).Aliases
+						length177 := uint32(len(slice175))
+						result176 := witRuntime.Allocate(pinner, uintptr(length177*(2*4)), 4)
+						for index, element := range slice175 {
+							base := unsafe.Add(result176, index*(2*4))
+							utf8174 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8174)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8174)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length177)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result176)))
+						slice179 := ((element).Metadata).Examples
+						length181 := uint32(len(slice179))
+						result180 := witRuntime.Allocate(pinner, uintptr(length181*(2*4)), 4)
+						for index, element := range slice179 {
+							base := unsafe.Add(result180, index*(2*4))
+							utf8178 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8178)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8178)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length181)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result180)))
+
+						switch ((element).Metadata).Deprecated.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Deprecated.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+							utf8182 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8182)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf8182)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch ((element).Metadata).Role.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Role.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.RoleMultimodal:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+							case golem_core_types.RoleUnstructuredText:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+							case golem_core_types.RoleUnstructuredBinary:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+							case golem_core_types.RoleOther:
+								payload := payload.Other()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+								utf8183 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8183)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf8183)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length186)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result185)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (element).OutputSchema.Tag() {
+				case golem_agent_common.OutputSchemaUnit:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = int8(int32(0))
+
+				case golem_agent_common.OutputSchemaSingle:
+					payload := (element).OutputSchema.Single()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = int8(int32(1))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 12*4))) = payload
+
+				default:
+					panic("unreachable")
+				}
+
+				switch (element).ReadOnly.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (element).ReadOnly.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+					switch (payload).CachePolicy.Tag() {
+					case golem_agent_common.CachePolicyNoCache:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4))) = int8(int32(0))
+
+					case golem_agent_common.CachePolicyUntilWrite:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4))) = int8(int32(1))
+
+					case golem_agent_common.CachePolicyTtl:
+						payload := (payload).CachePolicy.Ttl()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4))) = int8(int32(2))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 12*4))) = int64(payload)
+
+					default:
+						panic("unreachable")
+					}
+					var result187 int32
+					if (payload).UsesPrincipal {
+						result187 = 1
+					} else {
+						result187 = 0
+					}
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))) = int8(result187)
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (23 * 4))) = uint32(length190)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uintptr(uintptr(result189)))
+			slice384 := (element).Dependencies
+			length386 := uint32(len(slice384))
+			result385 := witRuntime.Allocate(pinner, uintptr(length386*(23*4)), 4)
+			for index, element := range slice384 {
+				base := unsafe.Add(result385, index*(23*4))
+				utf8191 := unsafe.Pointer(unsafe.StringData((element).TypeName))
+				pinner.Pin(utf8191)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).TypeName)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8191)))
+
+				switch (element).Description.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (element).Description.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+					utf8192 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8192)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8192)))
+
+				default:
+					panic("unreachable")
+				}
+				slice311 := ((element).Schema).TypeNodes
+				length313 := uint32(len(slice311))
+				result312 := witRuntime.Allocate(pinner, uintptr(length313*(56+22*4)), 8)
+				for index, element := range slice311 {
+					base := unsafe.Add(result312, index*(56+22*4))
+
+					switch (element).Body.Tag() {
+					case golem_core_types.SchemaTypeBodyRefType:
+						payload := (element).Body.RefType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaTypeBodyBoolType:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+					case golem_core_types.SchemaTypeBodyS8Type:
+						payload := (element).Body.S8Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf8193 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8193)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8193)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyS16Type:
+						payload := (element).Body.S16Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf8194 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8194)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8194)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyS32Type:
+						payload := (element).Body.S32Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf8195 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8195)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8195)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyS64Type:
+						payload := (element).Body.S64Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf8196 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8196)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8196)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyU8Type:
+						payload := (element).Body.U8Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf8197 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8197)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8197)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyU16Type:
+						payload := (element).Body.U16Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf8198 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8198)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8198)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyU32Type:
+						payload := (element).Body.U32Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf8199 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8199)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8199)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyU64Type:
+						payload := (element).Body.U64Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf8200 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8200)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8200)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyF32Type:
+						payload := (element).Body.F32Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf8201 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8201)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8201)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyF64Type:
+						payload := (element).Body.F64Type()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+							switch (payload).Min.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Min.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Max.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Max.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.NumericBoundSigned:
+									payload := payload.Signed()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+								case golem_core_types.NumericBoundUnsigned:
+									payload := payload.Unsigned()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								case golem_core_types.NumericBoundFloatBits:
+									payload := payload.FloatBits()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+									*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+							switch (payload).Unit.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Unit.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+								utf8202 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8202)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8202)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyCharType:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+
+					case golem_core_types.SchemaTypeBodyStringType:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+
+					case golem_core_types.SchemaTypeBodyRecordType:
+						payload := (element).Body.RecordType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+						slice215 := payload
+						length217 := uint32(len(slice215))
+						result216 := witRuntime.Allocate(pinner, uintptr(length217*(17*4)), 4)
+						for index, element := range slice215 {
+							base := unsafe.Add(result216, index*(17*4))
+							utf8203 := unsafe.Pointer(unsafe.StringData((element).Name))
+							pinner.Pin(utf8203)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8203)))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+							switch ((element).Metadata).Doc.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Doc.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+								utf8204 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8204)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8204)))
+
+							default:
+								panic("unreachable")
+							}
+							slice206 := ((element).Metadata).Aliases
+							length208 := uint32(len(slice206))
+							result207 := witRuntime.Allocate(pinner, uintptr(length208*(2*4)), 4)
+							for index, element := range slice206 {
+								base := unsafe.Add(result207, index*(2*4))
+								utf8205 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8205)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8205)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length208)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result207)))
+							slice210 := ((element).Metadata).Examples
+							length212 := uint32(len(slice210))
+							result211 := witRuntime.Allocate(pinner, uintptr(length212*(2*4)), 4)
+							for index, element := range slice210 {
+								base := unsafe.Add(result211, index*(2*4))
+								utf8209 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8209)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8209)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = uint32(length212)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result211)))
+
+							switch ((element).Metadata).Deprecated.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Deprecated.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(1))
+								utf8213 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8213)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf8213)))
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Role.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Role.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.RoleMultimodal:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(0))
+
+								case golem_core_types.RoleUnstructuredText:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(1))
+
+								case golem_core_types.RoleUnstructuredBinary:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(2))
+
+								case golem_core_types.RoleOther:
+									payload := payload.Other()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(3))
+									utf8214 := unsafe.Pointer(unsafe.StringData(payload))
+									pinner.Pin(utf8214)
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uint32(len(payload)))
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uintptr(uintptr(utf8214)))
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length217)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result216)))
+
+					case golem_core_types.SchemaTypeBodyVariantType:
+						payload := (element).Body.VariantType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+						slice230 := payload
+						length232 := uint32(len(slice230))
+						result231 := witRuntime.Allocate(pinner, uintptr(length232*(8+16*4)), 4)
+						for index, element := range slice230 {
+							base := unsafe.Add(result231, index*(8+16*4))
+							utf8218 := unsafe.Pointer(unsafe.StringData((element).Name))
+							pinner.Pin(utf8218)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8218)))
+
+							switch (element).Payload.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (element).Payload.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+								*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = payload
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Doc.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Doc.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+								utf8219 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8219)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8219)))
+
+							default:
+								panic("unreachable")
+							}
+							slice221 := ((element).Metadata).Aliases
+							length223 := uint32(len(slice221))
+							result222 := witRuntime.Allocate(pinner, uintptr(length223*(2*4)), 4)
+							for index, element := range slice221 {
+								base := unsafe.Add(result222, index*(2*4))
+								utf8220 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8220)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8220)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length223)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result222)))
+							slice225 := ((element).Metadata).Examples
+							length227 := uint32(len(slice225))
+							result226 := witRuntime.Allocate(pinner, uintptr(length227*(2*4)), 4)
+							for index, element := range slice225 {
+								base := unsafe.Add(result226, index*(2*4))
+								utf8224 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8224)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8224)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length227)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result226)))
+
+							switch ((element).Metadata).Deprecated.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Deprecated.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+								utf8228 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8228)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf8228)))
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Role.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Role.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.RoleMultimodal:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+								case golem_core_types.RoleUnstructuredText:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+								case golem_core_types.RoleUnstructuredBinary:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+								case golem_core_types.RoleOther:
+									payload := payload.Other()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+									utf8229 := unsafe.Pointer(unsafe.StringData(payload))
+									pinner.Pin(utf8229)
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf8229)))
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length232)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result231)))
+
+					case golem_core_types.SchemaTypeBodyEnumType:
+						payload := (element).Body.EnumType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+						slice234 := payload
+						length236 := uint32(len(slice234))
+						result235 := witRuntime.Allocate(pinner, uintptr(length236*(2*4)), 4)
+						for index, element := range slice234 {
+							base := unsafe.Add(result235, index*(2*4))
+							utf8233 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8233)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8233)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length236)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result235)))
+
+					case golem_core_types.SchemaTypeBodyFlagsType:
+						payload := (element).Body.FlagsType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+						slice238 := payload
+						length240 := uint32(len(slice238))
+						result239 := witRuntime.Allocate(pinner, uintptr(length240*(2*4)), 4)
+						for index, element := range slice238 {
+							base := unsafe.Add(result239, index*(2*4))
+							utf8237 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8237)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8237)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length240)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result239)))
+
+					case golem_core_types.SchemaTypeBodyTupleType:
+						payload := (element).Body.TupleType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+						slice241 := payload
+						length243 := uint32(len(slice241))
+						result242 := witRuntime.Allocate(pinner, uintptr(length243*4), 4)
+						for index, element := range slice241 {
+							base := unsafe.Add(result242, index*4)
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length243)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result242)))
+
+					case golem_core_types.SchemaTypeBodyListType:
+						payload := (element).Body.ListType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaTypeBodyFixedListType:
+						payload := (element).Body.FixedListType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Element
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Length)
+
+					case golem_core_types.SchemaTypeBodyMapType:
+						payload := (element).Body.MapType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Key
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Value
+
+					case golem_core_types.SchemaTypeBodyOptionType:
+						payload := (element).Body.OptionType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+					case golem_core_types.SchemaTypeBodyResultType:
+						payload := (element).Body.ResultType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+						switch (payload).Ok.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Ok.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Err.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Err.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyTextType:
+						payload := (element).Body.TextType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+						switch (payload).Languages.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Languages.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							slice245 := payload
+							length247 := uint32(len(slice245))
+							result246 := witRuntime.Allocate(pinner, uintptr(length247*(2*4)), 4)
+							for index, element := range slice245 {
+								base := unsafe.Add(result246, index*(2*4))
+								utf8244 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8244)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8244)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length247)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result246)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).MinLength.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MinLength.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).MaxLength.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MaxLength.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Regex.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Regex.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(1))
+							utf8248 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8248)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = uint32(uintptr(uintptr(utf8248)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyBinaryType:
+						payload := (element).Body.BinaryType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+
+						switch (payload).MimeTypes.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MimeTypes.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							slice250 := payload
+							length252 := uint32(len(slice250))
+							result251 := witRuntime.Allocate(pinner, uintptr(length252*(2*4)), 4)
+							for index, element := range slice250 {
+								base := unsafe.Add(result251, index*(2*4))
+								utf8249 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8249)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8249)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length252)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result251)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).MinBytes.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MinBytes.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).MaxBytes.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).MaxBytes.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyPathType:
+						payload := (element).Body.PathType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Direction))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Kind))
+
+						switch (payload).AllowedMimeTypes.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).AllowedMimeTypes.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+							slice254 := payload
+							length256 := uint32(len(slice254))
+							result255 := witRuntime.Allocate(pinner, uintptr(length256*(2*4)), 4)
+							for index, element := range slice254 {
+								base := unsafe.Add(result255, index*(2*4))
+								utf8253 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8253)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8253)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length256)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result255)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).AllowedExtensions.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).AllowedExtensions.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+							slice258 := payload
+							length260 := uint32(len(slice258))
+							result259 := witRuntime.Allocate(pinner, uintptr(length260*(2*4)), 4)
+							for index, element := range slice258 {
+								base := unsafe.Add(result259, index*(2*4))
+								utf8257 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8257)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8257)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length260)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result259)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyUrlType:
+						payload := (element).Body.UrlType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+
+						switch (payload).AllowedSchemes.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).AllowedSchemes.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							slice262 := payload
+							length264 := uint32(len(slice262))
+							result263 := witRuntime.Allocate(pinner, uintptr(length264*(2*4)), 4)
+							for index, element := range slice262 {
+								base := unsafe.Add(result263, index*(2*4))
+								utf8261 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8261)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8261)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length264)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result263)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).AllowedHosts.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).AllowedHosts.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+							slice266 := payload
+							length268 := uint32(len(slice266))
+							result267 := witRuntime.Allocate(pinner, uintptr(length268*(2*4)), 4)
+							for index, element := range slice266 {
+								base := unsafe.Add(result267, index*(2*4))
+								utf8265 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8265)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8265)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(length268)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(result267)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyDatetimeType:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+					case golem_core_types.SchemaTypeBodyDurationType:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+					case golem_core_types.SchemaTypeBodyQuantityType:
+						payload := (element).Body.QuantityType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+						utf8269 := unsafe.Pointer(unsafe.StringData((payload).BaseUnit))
+						pinner.Pin(utf8269)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).BaseUnit)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8269)))
+						slice271 := (payload).AllowedSuffixes
+						length273 := uint32(len(slice271))
+						result272 := witRuntime.Allocate(pinner, uintptr(length273*(2*4)), 4)
+						for index, element := range slice271 {
+							base := unsafe.Add(result272, index*(2*4))
+							utf8270 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8270)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8270)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length273)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result272)))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))) = (payload).Mantissa
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = (payload).Scale
+							utf8274 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+							pinner.Pin(utf8274)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))) = uint32(uint32(len((payload).Unit)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uintptr(uintptr(utf8274)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(1))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))) = (payload).Mantissa
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))) = (payload).Scale
+							utf8275 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+							pinner.Pin(utf8275)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))) = uint32(uint32(len((payload).Unit)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4))) = uint32(uintptr(uintptr(utf8275)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyUnionType:
+						payload := (element).Body.UnionType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+						slice295 := (payload).Branches
+						length297 := uint32(len(slice295))
+						result296 := witRuntime.Allocate(pinner, uintptr(length297*(23*4)), 4)
+						for index, element := range slice295 {
+							base := unsafe.Add(result296, index*(23*4))
+							utf8276 := unsafe.Pointer(unsafe.StringData((element).Tag))
+							pinner.Pin(utf8276)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Tag)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8276)))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+							switch (element).Discriminator.Tag() {
+							case golem_core_types.DiscriminatorRulePrefix:
+								payload := (element).Discriminator.Prefix()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+								utf8277 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8277)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8277)))
+
+							case golem_core_types.DiscriminatorRuleSuffix:
+								payload := (element).Discriminator.Suffix()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+								utf8278 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8278)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8278)))
+
+							case golem_core_types.DiscriminatorRuleContains:
+								payload := (element).Discriminator.Contains()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(2))
+								utf8279 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8279)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8279)))
+
+							case golem_core_types.DiscriminatorRuleRegex:
+								payload := (element).Discriminator.Regex()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(3))
+								utf8280 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8280)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8280)))
+
+							case golem_core_types.DiscriminatorRuleFieldEquals:
+								payload := (element).Discriminator.FieldEquals()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(4))
+								utf8281 := unsafe.Pointer(unsafe.StringData((payload).FieldName))
+								pinner.Pin(utf8281)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((payload).FieldName)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8281)))
+
+								switch (payload).Literal.Tag() {
+								case witTypes.OptionNone:
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+								case witTypes.OptionSome:
+									payload := (payload).Literal.Some()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+									utf8282 := unsafe.Pointer(unsafe.StringData(payload))
+									pinner.Pin(utf8282)
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8282)))
+
+								default:
+									panic("unreachable")
+								}
+
+							case golem_core_types.DiscriminatorRuleFieldAbsent:
+								payload := (element).Discriminator.FieldAbsent()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(5))
+								utf8283 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8283)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8283)))
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Doc.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Doc.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+								utf8284 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8284)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(utf8284)))
+
+							default:
+								panic("unreachable")
+							}
+							slice286 := ((element).Metadata).Aliases
+							length288 := uint32(len(slice286))
+							result287 := witRuntime.Allocate(pinner, uintptr(length288*(2*4)), 4)
+							for index, element := range slice286 {
+								base := unsafe.Add(result287, index*(2*4))
+								utf8285 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8285)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8285)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(length288)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(result287)))
+							slice290 := ((element).Metadata).Examples
+							length292 := uint32(len(slice290))
+							result291 := witRuntime.Allocate(pinner, uintptr(length292*(2*4)), 4)
+							for index, element := range slice290 {
+								base := unsafe.Add(result291, index*(2*4))
+								utf8289 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8289)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8289)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(length292)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(result291)))
+
+							switch ((element).Metadata).Deprecated.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Deprecated.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(1))
+								utf8293 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8293)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf8293)))
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Role.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Role.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.RoleMultimodal:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(0))
+
+								case golem_core_types.RoleUnstructuredText:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(1))
+
+								case golem_core_types.RoleUnstructuredBinary:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(2))
+
+								case golem_core_types.RoleOther:
+									payload := payload.Other()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(3))
+									utf8294 := unsafe.Pointer(unsafe.StringData(payload))
+									pinner.Pin(utf8294)
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uint32(len(payload)))
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(utf8294)))
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length297)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result296)))
+
+					case golem_core_types.SchemaTypeBodySecretType:
+						payload := (element).Body.SecretType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Inner
+
+						switch (payload).Category.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Category.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+							utf8298 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8298)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8298)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyQuotaTokenType:
+						payload := (element).Body.QuotaTokenType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+						switch (payload).ResourceName.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).ResourceName.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							utf8299 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8299)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf8299)))
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyFutureType:
+						payload := (element).Body.FutureType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.SchemaTypeBodyStreamType:
+						payload := (element).Body.StreamType()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Doc.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Doc.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(1))
+						utf8300 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8300)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4))) = uint32(uintptr(uintptr(utf8300)))
+
+					default:
+						panic("unreachable")
+					}
+					slice302 := ((element).Metadata).Aliases
+					length304 := uint32(len(slice302))
+					result303 := witRuntime.Allocate(pinner, uintptr(length304*(2*4)), 4)
+					for index, element := range slice302 {
+						base := unsafe.Add(result303, index*(2*4))
+						utf8301 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8301)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8301)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length304)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result303)))
+					slice306 := ((element).Metadata).Examples
+					length308 := uint32(len(slice306))
+					result307 := witRuntime.Allocate(pinner, uintptr(length308*(2*4)), 4)
+					for index, element := range slice306 {
+						base := unsafe.Add(result307, index*(2*4))
+						utf8305 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8305)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8305)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length308)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result307)))
+
+					switch ((element).Metadata).Deprecated.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Deprecated.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(1))
+						utf8309 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8309)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4))) = uint32(uintptr(uintptr(utf8309)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch ((element).Metadata).Role.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := ((element).Metadata).Role.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(1))
+
+						switch payload.Tag() {
+						case golem_core_types.RoleMultimodal:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(0))
+
+						case golem_core_types.RoleUnstructuredText:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(1))
+
+						case golem_core_types.RoleUnstructuredBinary:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(2))
+
+						case golem_core_types.RoleOther:
+							payload := payload.Other()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(3))
+							utf8310 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8310)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4))) = uint32(uintptr(uintptr(utf8310)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(length313)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uintptr(uintptr(result312)))
+				slice316 := ((element).Schema).Defs
+				length318 := uint32(len(slice316))
+				result317 := witRuntime.Allocate(pinner, uintptr(length318*(6*4)), 4)
+				for index, element := range slice316 {
+					base := unsafe.Add(result317, index*(6*4))
+					utf8314 := unsafe.Pointer(unsafe.StringData((element).Id))
+					pinner.Pin(utf8314)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8314)))
+
+					switch (element).Name.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (element).Name.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+						utf8315 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8315)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8315)))
+
+					default:
+						panic("unreachable")
+					}
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(length318)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(result317)))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = ((element).Schema).Root
+
+				switch ((element).Constructor).Name.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Constructor).Name.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(1))
+					utf8319 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8319)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf8319)))
+
+				default:
+					panic("unreachable")
+				}
+				utf8320 := unsafe.Pointer(unsafe.StringData(((element).Constructor).Description))
+				pinner.Pin(utf8320)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uint32(len(((element).Constructor).Description)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(uintptr(uintptr(utf8320)))
+
+				switch ((element).Constructor).PromptHint.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Constructor).PromptHint.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = int8(int32(1))
+					utf8321 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8321)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uintptr(uintptr(utf8321)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Constructor).InputSchema.Tag() {
+				case golem_agent_common.InputSchemaParameters:
+					payload := ((element).Constructor).InputSchema.Parameters()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = int8(int32(0))
+					slice334 := payload
+					length336 := uint32(len(slice334))
+					result335 := witRuntime.Allocate(pinner, uintptr(length336*(8+16*4)), 4)
+					for index, element := range slice334 {
+						base := unsafe.Add(result335, index*(8+16*4))
+						utf8322 := unsafe.Pointer(unsafe.StringData((element).Name))
+						pinner.Pin(utf8322)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8322)))
+
+						switch (element).Source.Tag() {
+						case golem_agent_common.FieldSourceUserSupplied:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+						case golem_agent_common.FieldSourceAutoInjected:
+							payload := (element).Source.AutoInjected()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))) = int8(int32(payload))
+
+						default:
+							panic("unreachable")
+						}
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = (element).Schema
+
+						switch ((element).Metadata).Doc.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Doc.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+							utf8323 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8323)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8323)))
+
+						default:
+							panic("unreachable")
+						}
+						slice325 := ((element).Metadata).Aliases
+						length327 := uint32(len(slice325))
+						result326 := witRuntime.Allocate(pinner, uintptr(length327*(2*4)), 4)
+						for index, element := range slice325 {
+							base := unsafe.Add(result326, index*(2*4))
+							utf8324 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8324)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8324)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length327)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result326)))
+						slice329 := ((element).Metadata).Examples
+						length331 := uint32(len(slice329))
+						result330 := witRuntime.Allocate(pinner, uintptr(length331*(2*4)), 4)
+						for index, element := range slice329 {
+							base := unsafe.Add(result330, index*(2*4))
+							utf8328 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8328)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8328)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length331)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result330)))
+
+						switch ((element).Metadata).Deprecated.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Deprecated.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+							utf8332 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8332)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf8332)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch ((element).Metadata).Role.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Role.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.RoleMultimodal:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+							case golem_core_types.RoleUnstructuredText:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+							case golem_core_types.RoleUnstructuredBinary:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+							case golem_core_types.RoleOther:
+								payload := payload.Other()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+								utf8333 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8333)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf8333)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = uint32(length336)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = uint32(uintptr(uintptr(result335)))
+
+				default:
+					panic("unreachable")
+				}
+				slice381 := (element).Methods
+				length383 := uint32(len(slice381))
+				result382 := witRuntime.Allocate(pinner, uintptr(length383*(40+12*4)), 8)
+				for index, element := range slice381 {
+					base := unsafe.Add(result382, index*(40+12*4))
+					utf8337 := unsafe.Pointer(unsafe.StringData((element).Name))
+					pinner.Pin(utf8337)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8337)))
+					utf8338 := unsafe.Pointer(unsafe.StringData((element).Description))
+					pinner.Pin(utf8338)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).Description)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8338)))
+					slice361 := (element).HttpEndpoint
+					length363 := uint32(len(slice361))
+					result362 := witRuntime.Allocate(pinner, uintptr(length363*(12*4)), 4)
+					for index, element := range slice361 {
+						base := unsafe.Add(result362, index*(12*4))
+
+						switch (element).HttpMethod.Tag() {
+						case golem_agent_common.HttpMethodGet:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+
+						case golem_agent_common.HttpMethodHead:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+						case golem_agent_common.HttpMethodPost:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+						case golem_agent_common.HttpMethodPut:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+						case golem_agent_common.HttpMethodDelete:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+						case golem_agent_common.HttpMethodConnect:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+						case golem_agent_common.HttpMethodOptions:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+						case golem_agent_common.HttpMethodTrace:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+						case golem_agent_common.HttpMethodPatch:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+						case golem_agent_common.HttpMethodCustom:
+							payload := (element).HttpMethod.Custom()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+							utf8339 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8339)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8339)))
+
+						default:
+							panic("unreachable")
+						}
+						slice343 := (element).PathSuffix
+						length345 := uint32(len(slice343))
+						result344 := witRuntime.Allocate(pinner, uintptr(length345*(3*4)), 4)
+						for index, element := range slice343 {
+							base := unsafe.Add(result344, index*(3*4))
+
+							switch element.Tag() {
+							case golem_agent_common.PathSegmentLiteral:
+								payload := element.Literal()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+								utf8340 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8340)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8340)))
+
+							case golem_agent_common.PathSegmentSystemVariable:
+								payload := element.SystemVariable()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 4)) = int8(int32(payload))
+
+							case golem_agent_common.PathSegmentPathVariable:
+								payload := element.PathVariable()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+								utf8341 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+								pinner.Pin(utf8341)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8341)))
+
+							case golem_agent_common.PathSegmentRemainingPathVariable:
+								payload := element.RemainingPathVariable()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+								utf8342 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+								pinner.Pin(utf8342)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8342)))
+
+							default:
+								panic("unreachable")
+							}
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(length345)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(result344)))
+						slice348 := (element).HeaderVars
+						length350 := uint32(len(slice348))
+						result349 := witRuntime.Allocate(pinner, uintptr(length350*(4*4)), 4)
+						for index, element := range slice348 {
+							base := unsafe.Add(result349, index*(4*4))
+							utf8346 := unsafe.Pointer(unsafe.StringData((element).HeaderName))
+							pinner.Pin(utf8346)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).HeaderName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8346)))
+							utf8347 := unsafe.Pointer(unsafe.StringData((element).VariableName))
+							pinner.Pin(utf8347)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8347)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(length350)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uintptr(uintptr(result349)))
+						slice353 := (element).QueryVars
+						length355 := uint32(len(slice353))
+						result354 := witRuntime.Allocate(pinner, uintptr(length355*(4*4)), 4)
+						for index, element := range slice353 {
+							base := unsafe.Add(result354, index*(4*4))
+							utf8351 := unsafe.Pointer(unsafe.StringData((element).QueryParamName))
+							pinner.Pin(utf8351)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).QueryParamName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8351)))
+							utf8352 := unsafe.Pointer(unsafe.StringData((element).VariableName))
+							pinner.Pin(utf8352)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8352)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(length355)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(result354)))
+
+						switch (element).AuthDetails.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (element).AuthDetails.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+							var result356 int32
+							if (payload).Required {
+								result356 = 1
+							} else {
+								result356 = 0
+							}
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 9*4))) = int8(result356)
+
+						default:
+							panic("unreachable")
+						}
+						slice358 := ((element).CorsOptions).AllowedPatterns
+						length360 := uint32(len(slice358))
+						result359 := witRuntime.Allocate(pinner, uintptr(length360*(2*4)), 4)
+						for index, element := range slice358 {
+							base := unsafe.Add(result359, index*(2*4))
+							utf8357 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8357)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8357)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length360)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result359)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(length363)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(result362)))
+
+					switch (element).PromptHint.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (element).PromptHint.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+						utf8364 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8364)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8364)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (element).InputSchema.Tag() {
+					case golem_agent_common.InputSchemaParameters:
+						payload := (element).InputSchema.Parameters()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+						slice377 := payload
+						length379 := uint32(len(slice377))
+						result378 := witRuntime.Allocate(pinner, uintptr(length379*(8+16*4)), 4)
+						for index, element := range slice377 {
+							base := unsafe.Add(result378, index*(8+16*4))
+							utf8365 := unsafe.Pointer(unsafe.StringData((element).Name))
+							pinner.Pin(utf8365)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8365)))
+
+							switch (element).Source.Tag() {
+							case golem_agent_common.FieldSourceUserSupplied:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+							case golem_agent_common.FieldSourceAutoInjected:
+								payload := (element).Source.AutoInjected()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 2*4))) = int8(int32(payload))
+
+							default:
+								panic("unreachable")
+							}
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = (element).Schema
+
+							switch ((element).Metadata).Doc.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Doc.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+								utf8366 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8366)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8366)))
+
+							default:
+								panic("unreachable")
+							}
+							slice368 := ((element).Metadata).Aliases
+							length370 := uint32(len(slice368))
+							result369 := witRuntime.Allocate(pinner, uintptr(length370*(2*4)), 4)
+							for index, element := range slice368 {
+								base := unsafe.Add(result369, index*(2*4))
+								utf8367 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8367)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8367)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length370)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result369)))
+							slice372 := ((element).Metadata).Examples
+							length374 := uint32(len(slice372))
+							result373 := witRuntime.Allocate(pinner, uintptr(length374*(2*4)), 4)
+							for index, element := range slice372 {
+								base := unsafe.Add(result373, index*(2*4))
+								utf8371 := unsafe.Pointer(unsafe.StringData(element))
+								pinner.Pin(utf8371)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8371)))
+
+							}
+
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length374)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result373)))
+
+							switch ((element).Metadata).Deprecated.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Deprecated.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+								utf8375 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8375)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf8375)))
+
+							default:
+								panic("unreachable")
+							}
+
+							switch ((element).Metadata).Role.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := ((element).Metadata).Role.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+								switch payload.Tag() {
+								case golem_core_types.RoleMultimodal:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+								case golem_core_types.RoleUnstructuredText:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+								case golem_core_types.RoleUnstructuredBinary:
+
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+								case golem_core_types.RoleOther:
+									payload := payload.Other()
+									*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+									utf8376 := unsafe.Pointer(unsafe.StringData(payload))
+									pinner.Pin(utf8376)
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+									*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf8376)))
+
+								default:
+									panic("unreachable")
+								}
+
+							default:
+								panic("unreachable")
+							}
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length379)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result378)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (element).OutputSchema.Tag() {
+					case golem_agent_common.OutputSchemaUnit:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = int8(int32(0))
+
+					case golem_agent_common.OutputSchemaSingle:
+						payload := (element).OutputSchema.Single()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 12*4))) = payload
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (element).ReadOnly.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (element).ReadOnly.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+						switch (payload).CachePolicy.Tag() {
+						case golem_agent_common.CachePolicyNoCache:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4))) = int8(int32(0))
+
+						case golem_agent_common.CachePolicyUntilWrite:
+
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4))) = int8(int32(1))
+
+						case golem_agent_common.CachePolicyTtl:
+							payload := (payload).CachePolicy.Ttl()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 12*4))) = int8(int32(2))
+							*(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 12*4))) = int64(payload)
+
+						default:
+							panic("unreachable")
+						}
+						var result380 int32
+						if (payload).UsesPrincipal {
+							result380 = 1
+						} else {
+							result380 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))) = int8(result380)
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(length383)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(result382)))
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (25 * 4))) = uint32(length386)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 * 4))) = uint32(uintptr(uintptr(result385)))
+			*(*int8)(unsafe.Add(unsafe.Pointer(base), (26 * 4))) = int8(int32((element).Mode))
+
+			switch (element).HttpMount.Tag() {
+			case witTypes.OptionNone:
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (27 * 4))) = int8(int32(0))
+
+			case witTypes.OptionSome:
+				payload := (element).HttpMount.Some()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (27 * 4))) = int8(int32(1))
+				slice390 := (payload).PathPrefix
+				length392 := uint32(len(slice390))
+				result391 := witRuntime.Allocate(pinner, uintptr(length392*(3*4)), 4)
+				for index, element := range slice390 {
+					base := unsafe.Add(result391, index*(3*4))
+
+					switch element.Tag() {
+					case golem_agent_common.PathSegmentLiteral:
+						payload := element.Literal()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+						utf8387 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8387)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8387)))
+
+					case golem_agent_common.PathSegmentSystemVariable:
+						payload := element.SystemVariable()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 4)) = int8(int32(payload))
+
+					case golem_agent_common.PathSegmentPathVariable:
+						payload := element.PathVariable()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+						utf8388 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+						pinner.Pin(utf8388)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8388)))
+
+					case golem_agent_common.PathSegmentRemainingPathVariable:
+						payload := element.RemainingPathVariable()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+						utf8389 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+						pinner.Pin(utf8389)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8389)))
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (29 * 4))) = uint32(length392)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (28 * 4))) = uint32(uintptr(uintptr(result391)))
+
+				switch (payload).AuthDetails.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (30 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (payload).AuthDetails.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (30 * 4))) = int8(int32(1))
+					var result393 int32
+					if (payload).Required {
+						result393 = 1
+					} else {
+						result393 = 0
+					}
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 30*4))) = int8(result393)
+
+				default:
+					panic("unreachable")
+				}
+				var result394 int32
+				if (payload).PhantomAgent {
+					result394 = 1
+				} else {
+					result394 = 0
+				}
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 + 30*4))) = int8(result394)
+				slice396 := ((payload).CorsOptions).AllowedPatterns
+				length398 := uint32(len(slice396))
+				result397 := witRuntime.Allocate(pinner, uintptr(length398*(2*4)), 4)
+				for index, element := range slice396 {
+					base := unsafe.Add(result397, index*(2*4))
+					utf8395 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8395)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8395)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 * 4))) = uint32(length398)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (31 * 4))) = uint32(uintptr(uintptr(result397)))
+				slice402 := (payload).WebhookSuffix
+				length404 := uint32(len(slice402))
+				result403 := witRuntime.Allocate(pinner, uintptr(length404*(3*4)), 4)
+				for index, element := range slice402 {
+					base := unsafe.Add(result403, index*(3*4))
+
+					switch element.Tag() {
+					case golem_agent_common.PathSegmentLiteral:
+						payload := element.Literal()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+						utf8399 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8399)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8399)))
+
+					case golem_agent_common.PathSegmentSystemVariable:
+						payload := element.SystemVariable()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 4)) = int8(int32(payload))
+
+					case golem_agent_common.PathSegmentPathVariable:
+						payload := element.PathVariable()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+						utf8400 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+						pinner.Pin(utf8400)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8400)))
+
+					case golem_agent_common.PathSegmentRemainingPathVariable:
+						payload := element.RemainingPathVariable()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+						utf8401 := unsafe.Pointer(unsafe.StringData((payload).VariableName))
+						pinner.Pin(utf8401)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8401)))
+
+					default:
+						panic("unreachable")
+					}
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (34 * 4))) = uint32(length404)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (33 * 4))) = uint32(uintptr(uintptr(result403)))
+
+			default:
+				panic("unreachable")
+			}
+
+			switch (element).Snapshotting.Tag() {
+			case golem_agent_common.SnapshottingDisabled:
+
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 34*4))) = int8(int32(0))
+
+			case golem_agent_common.SnapshottingEnabled:
+				payload := (element).Snapshotting.Enabled()
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 34*4))) = int8(int32(1))
+
+				switch payload.Tag() {
+				case golem_agent_common.SnapshottingConfigDefault:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 34*4))) = int8(int32(0))
+
+				case golem_agent_common.SnapshottingConfigPeriodic:
+					payload := payload.Periodic()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 34*4))) = int8(int32(1))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 34*4))) = int64(payload)
+
+				case golem_agent_common.SnapshottingConfigEveryNInvocation:
+					payload := payload.EveryNInvocation()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 34*4))) = int8(int32(2))
+					*(*int16)(unsafe.Add(unsafe.Pointer(base), (24 + 34*4))) = int16(int32(payload))
+
+				default:
+					panic("unreachable")
+				}
+
+			default:
+				panic("unreachable")
+			}
+			slice409 := (element).Config
+			length411 := uint32(len(slice409))
+			result410 := witRuntime.Allocate(pinner, uintptr(length411*(4*4)), 4)
+			for index, element := range slice409 {
+				base := unsafe.Add(result410, index*(4*4))
+				*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32((element).Source))
+				slice406 := (element).Path
+				length408 := uint32(len(slice406))
+				result407 := witRuntime.Allocate(pinner, uintptr(length408*(2*4)), 4)
+				for index, element := range slice406 {
+					base := unsafe.Add(result407, index*(2*4))
+					utf8405 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8405)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8405)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(length408)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(result407)))
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = (element).ValueType
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 35*4))) = uint32(length411)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 34*4))) = uint32(uintptr(uintptr(result410)))
+
+		}
+
+		*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (2 * 4))) = uint32(length414)
+		*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), 4)) = uint32(uintptr(uintptr(result413)))
+
+	case witTypes.ResultErr:
+		payload := result.Err()
+		*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), 0)) = int8(int32(1))
+
+		switch payload.Tag() {
+		case golem_agent_common.AgentErrorInvalidInput:
+			payload := payload.InvalidInput()
+			*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), 4)) = int8(int32(0))
+			utf8415 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8415)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (3 * 4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (2 * 4))) = uint32(uintptr(uintptr(utf8415)))
+
+		case golem_agent_common.AgentErrorInvalidMethod:
+			payload := payload.InvalidMethod()
+			*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), 4)) = int8(int32(1))
+			utf8416 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8416)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (3 * 4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (2 * 4))) = uint32(uintptr(uintptr(utf8416)))
+
+		case golem_agent_common.AgentErrorInvalidType:
+			payload := payload.InvalidType()
+			*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), 4)) = int8(int32(2))
+			utf8417 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8417)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (3 * 4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (2 * 4))) = uint32(uintptr(uintptr(utf8417)))
+
+		case golem_agent_common.AgentErrorInvalidAgentId:
+			payload := payload.InvalidAgentId()
+			*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), 4)) = int8(int32(3))
+			utf8418 := unsafe.Pointer(unsafe.StringData(payload))
+			pinner.Pin(utf8418)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (3 * 4))) = uint32(uint32(len(payload)))
+			*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (2 * 4))) = uint32(uintptr(uintptr(utf8418)))
+
+		case golem_agent_common.AgentErrorCustomError:
+			payload := payload.CustomError()
+			*(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), 4)) = int8(int32(4))
+			slice537 := ((payload).Graph).TypeNodes
+			length539 := uint32(len(slice537))
+			result538 := witRuntime.Allocate(pinner, uintptr(length539*(56+22*4)), 8)
+			for index, element := range slice537 {
+				base := unsafe.Add(result538, index*(56+22*4))
+
+				switch (element).Body.Tag() {
+				case golem_core_types.SchemaTypeBodyRefType:
+					payload := (element).Body.RefType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+				case golem_core_types.SchemaTypeBodyBoolType:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+
+				case golem_core_types.SchemaTypeBodyS8Type:
+					payload := (element).Body.S8Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf8419 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8419)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8419)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyS16Type:
+					payload := (element).Body.S16Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf8420 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8420)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8420)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyS32Type:
+					payload := (element).Body.S32Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf8421 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8421)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8421)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyS64Type:
+					payload := (element).Body.S64Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf8422 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8422)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8422)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyU8Type:
+					payload := (element).Body.U8Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf8423 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8423)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8423)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyU16Type:
+					payload := (element).Body.U16Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf8424 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8424)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8424)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyU32Type:
+					payload := (element).Body.U32Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf8425 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8425)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8425)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyU64Type:
+					payload := (element).Body.U64Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf8426 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8426)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8426)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyF32Type:
+					payload := (element).Body.F32Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf8427 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8427)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8427)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyF64Type:
+					payload := (element).Body.F64Type()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch (payload).Min.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Min.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 24)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Max.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Max.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 40)) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.NumericBoundSigned:
+								payload := payload.Signed()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(0))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = payload
+
+							case golem_core_types.NumericBoundUnsigned:
+								payload := payload.Unsigned()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(1))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							case golem_core_types.NumericBoundFloatBits:
+								payload := payload.FloatBits()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), 48)) = int8(int32(2))
+								*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)) = int64(payload)
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+						switch (payload).Unit.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (payload).Unit.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 64)) = int8(int32(1))
+							utf8428 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8428)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4))) = uint32(uintptr(uintptr(utf8428)))
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyCharType:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+
+				case golem_core_types.SchemaTypeBodyStringType:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+
+				case golem_core_types.SchemaTypeBodyRecordType:
+					payload := (element).Body.RecordType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+					slice441 := payload
+					length443 := uint32(len(slice441))
+					result442 := witRuntime.Allocate(pinner, uintptr(length443*(17*4)), 4)
+					for index, element := range slice441 {
+						base := unsafe.Add(result442, index*(17*4))
+						utf8429 := unsafe.Pointer(unsafe.StringData((element).Name))
+						pinner.Pin(utf8429)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8429)))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+						switch ((element).Metadata).Doc.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Doc.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+							utf8430 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8430)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8430)))
+
+						default:
+							panic("unreachable")
+						}
+						slice432 := ((element).Metadata).Aliases
+						length434 := uint32(len(slice432))
+						result433 := witRuntime.Allocate(pinner, uintptr(length434*(2*4)), 4)
+						for index, element := range slice432 {
+							base := unsafe.Add(result433, index*(2*4))
+							utf8431 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8431)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8431)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length434)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result433)))
+						slice436 := ((element).Metadata).Examples
+						length438 := uint32(len(slice436))
+						result437 := witRuntime.Allocate(pinner, uintptr(length438*(2*4)), 4)
+						for index, element := range slice436 {
+							base := unsafe.Add(result437, index*(2*4))
+							utf8435 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8435)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8435)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = uint32(length438)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result437)))
+
+						switch ((element).Metadata).Deprecated.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Deprecated.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = int8(int32(1))
+							utf8439 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8439)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf8439)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch ((element).Metadata).Role.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Role.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.RoleMultimodal:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(0))
+
+							case golem_core_types.RoleUnstructuredText:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(1))
+
+							case golem_core_types.RoleUnstructuredBinary:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(2))
+
+							case golem_core_types.RoleOther:
+								payload := payload.Other()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = int8(int32(3))
+								utf8440 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8440)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uintptr(uintptr(utf8440)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length443)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result442)))
+
+				case golem_core_types.SchemaTypeBodyVariantType:
+					payload := (element).Body.VariantType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+					slice456 := payload
+					length458 := uint32(len(slice456))
+					result457 := witRuntime.Allocate(pinner, uintptr(length458*(8+16*4)), 4)
+					for index, element := range slice456 {
+						base := unsafe.Add(result457, index*(8+16*4))
+						utf8444 := unsafe.Pointer(unsafe.StringData((element).Name))
+						pinner.Pin(utf8444)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8444)))
+
+						switch (element).Payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := (element).Payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4))) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+						switch ((element).Metadata).Doc.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Doc.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+							utf8445 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8445)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8445)))
+
+						default:
+							panic("unreachable")
+						}
+						slice447 := ((element).Metadata).Aliases
+						length449 := uint32(len(slice447))
+						result448 := witRuntime.Allocate(pinner, uintptr(length449*(2*4)), 4)
+						for index, element := range slice447 {
+							base := unsafe.Add(result448, index*(2*4))
+							utf8446 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8446)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8446)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length449)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result448)))
+						slice451 := ((element).Metadata).Examples
+						length453 := uint32(len(slice451))
+						result452 := witRuntime.Allocate(pinner, uintptr(length453*(2*4)), 4)
+						for index, element := range slice451 {
+							base := unsafe.Add(result452, index*(2*4))
+							utf8450 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8450)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8450)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length453)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result452)))
+
+						switch ((element).Metadata).Deprecated.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Deprecated.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4))) = int8(int32(1))
+							utf8454 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8454)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4))) = uint32(uintptr(uintptr(utf8454)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch ((element).Metadata).Role.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Role.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4))) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.RoleMultimodal:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(0))
+
+							case golem_core_types.RoleUnstructuredText:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(1))
+
+							case golem_core_types.RoleUnstructuredBinary:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(2))
+
+							case golem_core_types.RoleOther:
+								payload := payload.Other()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4))) = int8(int32(3))
+								utf8455 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8455)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4))) = uint32(uintptr(uintptr(utf8455)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length458)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result457)))
+
+				case golem_core_types.SchemaTypeBodyEnumType:
+					payload := (element).Body.EnumType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+					slice460 := payload
+					length462 := uint32(len(slice460))
+					result461 := witRuntime.Allocate(pinner, uintptr(length462*(2*4)), 4)
+					for index, element := range slice460 {
+						base := unsafe.Add(result461, index*(2*4))
+						utf8459 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8459)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8459)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length462)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result461)))
+
+				case golem_core_types.SchemaTypeBodyFlagsType:
+					payload := (element).Body.FlagsType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+					slice464 := payload
+					length466 := uint32(len(slice464))
+					result465 := witRuntime.Allocate(pinner, uintptr(length466*(2*4)), 4)
+					for index, element := range slice464 {
+						base := unsafe.Add(result465, index*(2*4))
+						utf8463 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8463)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8463)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length466)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result465)))
+
+				case golem_core_types.SchemaTypeBodyTupleType:
+					payload := (element).Body.TupleType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+					slice467 := payload
+					length469 := uint32(len(slice467))
+					result468 := witRuntime.Allocate(pinner, uintptr(length469*4), 4)
+					for index, element := range slice467 {
+						base := unsafe.Add(result468, index*4)
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length469)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result468)))
+
+				case golem_core_types.SchemaTypeBodyListType:
+					payload := (element).Body.ListType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+				case golem_core_types.SchemaTypeBodyFixedListType:
+					payload := (element).Body.FixedListType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Element
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = int32((payload).Length)
+
+				case golem_core_types.SchemaTypeBodyMapType:
+					payload := (element).Body.MapType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Key
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = (payload).Value
+
+				case golem_core_types.SchemaTypeBodyOptionType:
+					payload := (element).Body.OptionType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+				case golem_core_types.SchemaTypeBodyResultType:
+					payload := (element).Body.ResultType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+
+					switch (payload).Ok.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Ok.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Err.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Err.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 16)) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 20)) = payload
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyTextType:
+					payload := (element).Body.TextType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+
+					switch (payload).Languages.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Languages.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+						slice471 := payload
+						length473 := uint32(len(slice471))
+						result472 := witRuntime.Allocate(pinner, uintptr(length473*(2*4)), 4)
+						for index, element := range slice471 {
+							base := unsafe.Add(result472, index*(2*4))
+							utf8470 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8470)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8470)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length473)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result472)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).MinLength.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).MinLength.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).MaxLength.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).MaxLength.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Regex.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Regex.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4))) = int8(int32(1))
+						utf8474 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8474)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = uint32(uintptr(uintptr(utf8474)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyBinaryType:
+					payload := (element).Body.BinaryType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+
+					switch (payload).MimeTypes.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).MimeTypes.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+						slice476 := payload
+						length478 := uint32(len(slice476))
+						result477 := witRuntime.Allocate(pinner, uintptr(length478*(2*4)), 4)
+						for index, element := range slice476 {
+							base := unsafe.Add(result477, index*(2*4))
+							utf8475 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8475)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8475)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length478)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result477)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).MinBytes.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).MinBytes.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))) = int32(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).MaxBytes.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).MaxBytes.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4))) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))) = int32(payload)
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyPathType:
+					payload := (element).Body.PathType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32((payload).Direction))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 9)) = int8(int32((payload).Kind))
+
+					switch (payload).AllowedMimeTypes.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).AllowedMimeTypes.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+						slice480 := payload
+						length482 := uint32(len(slice480))
+						result481 := witRuntime.Allocate(pinner, uintptr(length482*(2*4)), 4)
+						for index, element := range slice480 {
+							base := unsafe.Add(result481, index*(2*4))
+							utf8479 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8479)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8479)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length482)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result481)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).AllowedExtensions.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).AllowedExtensions.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+						slice484 := payload
+						length486 := uint32(len(slice484))
+						result485 := witRuntime.Allocate(pinner, uintptr(length486*(2*4)), 4)
+						for index, element := range slice484 {
+							base := unsafe.Add(result485, index*(2*4))
+							utf8483 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8483)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8483)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length486)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result485)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyUrlType:
+					payload := (element).Body.UrlType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+
+					switch (payload).AllowedSchemes.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).AllowedSchemes.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+						slice488 := payload
+						length490 := uint32(len(slice488))
+						result489 := witRuntime.Allocate(pinner, uintptr(length490*(2*4)), 4)
+						for index, element := range slice488 {
+							base := unsafe.Add(result489, index*(2*4))
+							utf8487 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8487)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8487)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length490)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result489)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).AllowedHosts.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).AllowedHosts.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = int8(int32(1))
+						slice492 := payload
+						length494 := uint32(len(slice492))
+						result493 := witRuntime.Allocate(pinner, uintptr(length494*(2*4)), 4)
+						for index, element := range slice492 {
+							base := unsafe.Add(result493, index*(2*4))
+							utf8491 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8491)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8491)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(length494)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(result493)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyDatetimeType:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+
+				case golem_core_types.SchemaTypeBodyDurationType:
+
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+
+				case golem_core_types.SchemaTypeBodyQuantityType:
+					payload := (element).Body.QuantityType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+					utf8495 := unsafe.Pointer(unsafe.StringData((payload).BaseUnit))
+					pinner.Pin(utf8495)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).BaseUnit)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8495)))
+					slice497 := (payload).AllowedSuffixes
+					length499 := uint32(len(slice497))
+					result498 := witRuntime.Allocate(pinner, uintptr(length499*(2*4)), 4)
+					for index, element := range slice497 {
+						base := unsafe.Add(result498, index*(2*4))
+						utf8496 := unsafe.Pointer(unsafe.StringData(element))
+						pinner.Pin(utf8496)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8496)))
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length499)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result498)))
+
+					switch (payload).Min.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Min.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4))) = (payload).Mantissa
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4))) = (payload).Scale
+						utf8500 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+						pinner.Pin(utf8500)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4))) = uint32(uint32(len((payload).Unit)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4))) = uint32(uintptr(uintptr(utf8500)))
+
+					default:
+						panic("unreachable")
+					}
+
+					switch (payload).Max.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Max.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4))) = int8(int32(1))
+						*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4))) = (payload).Mantissa
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4))) = (payload).Scale
+						utf8501 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+						pinner.Pin(utf8501)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4))) = uint32(uint32(len((payload).Unit)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4))) = uint32(uintptr(uintptr(utf8501)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyUnionType:
+					payload := (element).Body.UnionType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+					slice521 := (payload).Branches
+					length523 := uint32(len(slice521))
+					result522 := witRuntime.Allocate(pinner, uintptr(length523*(23*4)), 4)
+					for index, element := range slice521 {
+						base := unsafe.Add(result522, index*(23*4))
+						utf8502 := unsafe.Pointer(unsafe.StringData((element).Tag))
+						pinner.Pin(utf8502)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Tag)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8502)))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = (element).Body
+
+						switch (element).Discriminator.Tag() {
+						case golem_core_types.DiscriminatorRulePrefix:
+							payload := (element).Discriminator.Prefix()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(0))
+							utf8503 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8503)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8503)))
+
+						case golem_core_types.DiscriminatorRuleSuffix:
+							payload := (element).Discriminator.Suffix()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1))
+							utf8504 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8504)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8504)))
+
+						case golem_core_types.DiscriminatorRuleContains:
+							payload := (element).Discriminator.Contains()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(2))
+							utf8505 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8505)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8505)))
+
+						case golem_core_types.DiscriminatorRuleRegex:
+							payload := (element).Discriminator.Regex()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(3))
+							utf8506 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8506)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8506)))
+
+						case golem_core_types.DiscriminatorRuleFieldEquals:
+							payload := (element).Discriminator.FieldEquals()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(4))
+							utf8507 := unsafe.Pointer(unsafe.StringData((payload).FieldName))
+							pinner.Pin(utf8507)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((payload).FieldName)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8507)))
+
+							switch (payload).Literal.Tag() {
+							case witTypes.OptionNone:
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(0))
+
+							case witTypes.OptionSome:
+								payload := (payload).Literal.Some()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = int8(int32(1))
+								utf8508 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8508)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8508)))
+
+							default:
+								panic("unreachable")
+							}
+
+						case golem_core_types.DiscriminatorRuleFieldAbsent:
+							payload := (element).Discriminator.FieldAbsent()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(5))
+							utf8509 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8509)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8509)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch ((element).Metadata).Doc.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Doc.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = int8(int32(1))
+							utf8510 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8510)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(utf8510)))
+
+						default:
+							panic("unreachable")
+						}
+						slice512 := ((element).Metadata).Aliases
+						length514 := uint32(len(slice512))
+						result513 := witRuntime.Allocate(pinner, uintptr(length514*(2*4)), 4)
+						for index, element := range slice512 {
+							base := unsafe.Add(result513, index*(2*4))
+							utf8511 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8511)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8511)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(length514)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(result513)))
+						slice516 := ((element).Metadata).Examples
+						length518 := uint32(len(slice516))
+						result517 := witRuntime.Allocate(pinner, uintptr(length518*(2*4)), 4)
+						for index, element := range slice516 {
+							base := unsafe.Add(result517, index*(2*4))
+							utf8515 := unsafe.Pointer(unsafe.StringData(element))
+							pinner.Pin(utf8515)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8515)))
+
+						}
+
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(length518)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(result517)))
+
+						switch ((element).Metadata).Deprecated.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Deprecated.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = int8(int32(1))
+							utf8519 := unsafe.Pointer(unsafe.StringData(payload))
+							pinner.Pin(utf8519)
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload)))
+							*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf8519)))
+
+						default:
+							panic("unreachable")
+						}
+
+						switch ((element).Metadata).Role.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := ((element).Metadata).Role.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = int8(int32(1))
+
+							switch payload.Tag() {
+							case golem_core_types.RoleMultimodal:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(0))
+
+							case golem_core_types.RoleUnstructuredText:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(1))
+
+							case golem_core_types.RoleUnstructuredBinary:
+
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(2))
+
+							case golem_core_types.RoleOther:
+								payload := payload.Other()
+								*(*int8)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = int8(int32(3))
+								utf8520 := unsafe.Pointer(unsafe.StringData(payload))
+								pinner.Pin(utf8520)
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uint32(len(payload)))
+								*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(utf8520)))
+
+							default:
+								panic("unreachable")
+							}
+
+						default:
+							panic("unreachable")
+						}
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length523)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result522)))
+
+				case golem_core_types.SchemaTypeBodySecretType:
+					payload := (element).Body.SecretType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Inner
+
+					switch (payload).Category.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Category.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = int8(int32(1))
+						utf8524 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8524)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(utf8524)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyQuotaTokenType:
+					payload := (element).Body.QuotaTokenType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33))
+
+					switch (payload).ResourceName.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).ResourceName.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+						utf8525 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8525)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(utf8525)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyFutureType:
+					payload := (element).Body.FutureType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaTypeBodyStreamType:
+					payload := (element).Body.StreamType()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(35))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Doc.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Doc.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4))) = int8(int32(1))
+					utf8526 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8526)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4))) = uint32(uintptr(uintptr(utf8526)))
+
+				default:
+					panic("unreachable")
+				}
+				slice528 := ((element).Metadata).Aliases
+				length530 := uint32(len(slice528))
+				result529 := witRuntime.Allocate(pinner, uintptr(length530*(2*4)), 4)
+				for index, element := range slice528 {
+					base := unsafe.Add(result529, index*(2*4))
+					utf8527 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8527)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8527)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length530)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result529)))
+				slice532 := ((element).Metadata).Examples
+				length534 := uint32(len(slice532))
+				result533 := witRuntime.Allocate(pinner, uintptr(length534*(2*4)), 4)
+				for index, element := range slice532 {
+					base := unsafe.Add(result533, index*(2*4))
+					utf8531 := unsafe.Pointer(unsafe.StringData(element))
+					pinner.Pin(utf8531)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8531)))
+
+				}
+
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length534)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result533)))
+
+				switch ((element).Metadata).Deprecated.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Deprecated.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4))) = int8(int32(1))
+					utf8535 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8535)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4))) = uint32(uintptr(uintptr(utf8535)))
+
+				default:
+					panic("unreachable")
+				}
+
+				switch ((element).Metadata).Role.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := ((element).Metadata).Role.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4))) = int8(int32(1))
+
+					switch payload.Tag() {
+					case golem_core_types.RoleMultimodal:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(0))
+
+					case golem_core_types.RoleUnstructuredText:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(1))
+
+					case golem_core_types.RoleUnstructuredBinary:
+
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(2))
+
+					case golem_core_types.RoleOther:
+						payload := payload.Other()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4))) = int8(int32(3))
+						utf8536 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8536)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4))) = uint32(uintptr(uintptr(utf8536)))
+
+					default:
+						panic("unreachable")
+					}
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (3 * 4))) = uint32(length539)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (2 * 4))) = uint32(uintptr(uintptr(result538)))
+			slice542 := ((payload).Graph).Defs
+			length544 := uint32(len(slice542))
+			result543 := witRuntime.Allocate(pinner, uintptr(length544*(6*4)), 4)
+			for index, element := range slice542 {
+				base := unsafe.Add(result543, index*(6*4))
+				utf8540 := unsafe.Pointer(unsafe.StringData((element).Id))
+				pinner.Pin(utf8540)
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id)))
+				*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8540)))
+
+				switch (element).Name.Tag() {
+				case witTypes.OptionNone:
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(0))
+
+				case witTypes.OptionSome:
+					payload := (element).Name.Some()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(int32(1))
+					utf8541 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8541)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8541)))
+
+				default:
+					panic("unreachable")
+				}
+				*(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (5 * 4))) = uint32(length544)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (4 * 4))) = uint32(uintptr(uintptr(result543)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (6 * 4))) = ((payload).Graph).Root
+			slice573 := ((payload).Value).ValueNodes
+			length575 := uint32(len(slice573))
+			result574 := witRuntime.Allocate(pinner, uintptr(length575*(16+4*4)), 8)
+			for index, element := range slice573 {
+				base := unsafe.Add(result574, index*(16+4*4))
+
+				switch element.Tag() {
+				case golem_core_types.SchemaValueNodeBoolValue:
+					payload := element.BoolValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0))
+					var result545 int32
+					if payload {
+						result545 = 1
+					} else {
+						result545 = 0
+					}
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result545)
+
+				case golem_core_types.SchemaValueNodeS8Value:
+					payload := element.S8Value()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(1))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+				case golem_core_types.SchemaValueNodeS16Value:
+					payload := element.S16Value()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(2))
+					*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+				case golem_core_types.SchemaValueNodeS32Value:
+					payload := element.S32Value()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+				case golem_core_types.SchemaValueNodeS64Value:
+					payload := element.S64Value()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(4))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+				case golem_core_types.SchemaValueNodeU8Value:
+					payload := element.U8Value()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(5))
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(payload))
+
+				case golem_core_types.SchemaValueNodeU16Value:
+					payload := element.U16Value()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(6))
+					*(*int16)(unsafe.Add(unsafe.Pointer(base), 8)) = int16(int32(payload))
+
+				case golem_core_types.SchemaValueNodeU32Value:
+					payload := element.U32Value()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(7))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+				case golem_core_types.SchemaValueNodeU64Value:
+					payload := element.U64Value()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(8))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = int64(payload)
+
+				case golem_core_types.SchemaValueNodeF32Value:
+					payload := element.F32Value()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(9))
+					*(*float32)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+				case golem_core_types.SchemaValueNodeF64Value:
+					payload := element.F64Value()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(10))
+					*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)) = payload
+
+				case golem_core_types.SchemaValueNodeCharValue:
+					payload := element.CharValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(11))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+				case golem_core_types.SchemaValueNodeStringValue:
+					payload := element.StringValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(12))
+					utf8546 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8546)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8546)))
+
+				case golem_core_types.SchemaValueNodeRecordValue:
+					payload := element.RecordValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13))
+					slice547 := payload
+					length549 := uint32(len(slice547))
+					result548 := witRuntime.Allocate(pinner, uintptr(length549*4), 4)
+					for index, element := range slice547 {
+						base := unsafe.Add(result548, index*4)
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length549)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result548)))
+
+				case golem_core_types.SchemaValueNodeVariantValue:
+					payload := element.VariantValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(14))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32((payload).Case)
+
+					switch (payload).Payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaValueNodeEnumValue:
+					payload := element.EnumValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = int32(payload)
+
+				case golem_core_types.SchemaValueNodeFlagsValue:
+					payload := element.FlagsValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16))
+					slice551 := payload
+					length553 := uint32(len(slice551))
+					result552 := witRuntime.Allocate(pinner, uintptr(length553*1), 1)
+					for index, element := range slice551 {
+						base := unsafe.Add(result552, index*1)
+						var result550 int32
+						if element {
+							result550 = 1
+						} else {
+							result550 = 0
+						}
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result550)
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length553)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result552)))
+
+				case golem_core_types.SchemaValueNodeTupleValue:
+					payload := element.TupleValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17))
+					slice554 := payload
+					length556 := uint32(len(slice554))
+					result555 := witRuntime.Allocate(pinner, uintptr(length556*4), 4)
+					for index, element := range slice554 {
+						base := unsafe.Add(result555, index*4)
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length556)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result555)))
+
+				case golem_core_types.SchemaValueNodeListValue:
+					payload := element.ListValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18))
+					slice557 := payload
+					length559 := uint32(len(slice557))
+					result558 := witRuntime.Allocate(pinner, uintptr(length559*4), 4)
+					for index, element := range slice557 {
+						base := unsafe.Add(result558, index*4)
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length559)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result558)))
+
+				case golem_core_types.SchemaValueNodeFixedListValue:
+					payload := element.FixedListValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19))
+					slice560 := payload
+					length562 := uint32(len(slice560))
+					result561 := witRuntime.Allocate(pinner, uintptr(length562*4), 4)
+					for index, element := range slice560 {
+						base := unsafe.Add(result561, index*4)
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length562)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result561)))
+
+				case golem_core_types.SchemaValueNodeMapValue:
+					payload := element.MapValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20))
+					slice563 := payload
+					length565 := uint32(len(slice563))
+					result564 := witRuntime.Allocate(pinner, uintptr(length565*8), 4)
+					for index, element := range slice563 {
+						base := unsafe.Add(result564, index*8)
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = (element).Key
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)) = (element).Value
+
+					}
+
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length565)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result564)))
+
+				case golem_core_types.SchemaValueNodeOptionValue:
+					payload := element.OptionValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(21))
+
+					switch payload.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := payload.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+						*(*int32)(unsafe.Add(unsafe.Pointer(base), 12)) = payload
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaValueNodeResultValue:
+					payload := element.ResultValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(22))
+
+					switch payload.Tag() {
+					case golem_core_types.ResultValuePayloadOkValue:
+						payload := payload.OkValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(0))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					case golem_core_types.ResultValuePayloadErrValue:
+						payload := payload.ErrValue()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(int32(1))
+
+						switch payload.Tag() {
+						case witTypes.OptionNone:
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(0))
+
+						case witTypes.OptionSome:
+							payload := payload.Some()
+							*(*int8)(unsafe.Add(unsafe.Pointer(base), 12)) = int8(int32(1))
+							*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = payload
+
+						default:
+							panic("unreachable")
+						}
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaValueNodeTextValue:
+					payload := element.TextValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(23))
+					utf8566 := unsafe.Pointer(unsafe.StringData((payload).Text))
+					pinner.Pin(utf8566)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8566)))
+
+					switch (payload).Language.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).Language.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						utf8567 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8567)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8567)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaValueNodeBinaryValue:
+					payload := element.BinaryValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24))
+					data := unsafe.Pointer(unsafe.SliceData((payload).Bytes))
+					pinner.Pin(data)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data)))
+
+					switch (payload).MimeType.Tag() {
+					case witTypes.OptionNone:
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(0))
+
+					case witTypes.OptionSome:
+						payload := (payload).MimeType.Some()
+						*(*int8)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = int8(int32(1))
+						utf8568 := unsafe.Pointer(unsafe.StringData(payload))
+						pinner.Pin(utf8568)
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uint32(len(payload)))
+						*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(uintptr(uintptr(utf8568)))
+
+					default:
+						panic("unreachable")
+					}
+
+				case golem_core_types.SchemaValueNodePathValue:
+					payload := element.PathValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25))
+					utf8569 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8569)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8569)))
+
+				case golem_core_types.SchemaValueNodeUrlValue:
+					payload := element.UrlValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26))
+					utf8570 := unsafe.Pointer(unsafe.StringData(payload))
+					pinner.Pin(utf8570)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8570)))
+
+				case golem_core_types.SchemaValueNodeDatetimeValue:
+					payload := element.DatetimeValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(27))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Seconds
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = int32((payload).Nanoseconds)
+
+				case golem_core_types.SchemaValueNodeDurationValue:
+					payload := element.DurationValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(28))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Nanoseconds
+
+				case golem_core_types.SchemaValueNodeQuantityValueNode:
+					payload := element.QuantityValueNode()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(29))
+					*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).Mantissa
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 16)) = (payload).Scale
+					utf8571 := unsafe.Pointer(unsafe.StringData((payload).Unit))
+					pinner.Pin(utf8571)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4))) = uint32(uint32(len((payload).Unit)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4))) = uint32(uintptr(uintptr(utf8571)))
+
+				case golem_core_types.SchemaValueNodeUnionValue:
+					payload := element.UnionValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30))
+					utf8572 := unsafe.Pointer(unsafe.StringData((payload).Tag))
+					pinner.Pin(utf8572)
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag)))
+					*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8572)))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = (payload).Body
+
+				case golem_core_types.SchemaValueNodeSecretValue:
+					payload := element.SecretValue()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+				case golem_core_types.SchemaValueNodeQuotaTokenHandle:
+					payload := element.QuotaTokenHandle()
+					*(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(32))
+					*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle()
+
+				default:
+					panic("unreachable")
+				}
+
+			}
+
+			*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (8 * 4))) = uint32(length575)
+			*(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (7 * 4))) = uint32(uintptr(uintptr(result574)))
+			*(*int32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (9 * 4))) = ((payload).Value).Root
+
+		default:
+			panic("unreachable")
+		}
+
+	default:
+		panic("unreachable")
+	}
+	return exportReturnArea
+
+}
+
+//go:wasmexport cabi_post_golem:agent/guest@2.0.0#discover-agent-types
+func wasm_export_post_return_golem_agent_guest_discover_agent_types(result uintptr) {
+	syncExportPinner.Unpin()
+}
diff --git a/sdks/go/golem/keyvalue/keyvalue.go b/sdks/go/golem/keyvalue/keyvalue.go
new file mode 100644
index 0000000000..03d27314eb
--- /dev/null
+++ b/sdks/go/golem/keyvalue/keyvalue.go
@@ -0,0 +1,229 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 keyvalue is a Go wrapper over Golem's durable key-value store
+// (wasi:keyvalue). Open a [Bucket] by name and Get/Set/Delete/Exists byte values,
+// or wrap it with [Typed] for a JSON-encoded [Store] of a Go type.
+//
+// Unlike the exactly-once control-flow surface (RPC, promises, durability,
+// transactions), which is fail-loud, these are I/O operations whose failures a
+// caller can handle, so they return an error. A missing key is not an error: Get
+// returns (nil, false, nil). The store is durable — operations are journaled and
+// replayed — but because they are remote side effects, calling them inside a
+// read-only method traps.
+//
+// Pair a fallible call with golem.Must / golem.Must0 / golem.Must2 to abort the
+// invocation on error.
+package keyvalue
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	eventual "github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_keyvalue_eventual"
+	batch "github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_keyvalue_eventual_batch"
+	kvtypes "github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_keyvalue_types"
+	kverr "github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_keyvalue_wasi_keyvalue_error"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// Error is a key-value host error, carrying the host's diagnostic trace.
+type Error struct{ Trace string }
+
+func (e *Error) Error() string { return "golem/keyvalue: " + e.Trace }
+
+func kvError(e *kverr.Error) error {
+	if e == nil {
+		return errors.New("golem/keyvalue: unknown error")
+	}
+	return &Error{Trace: e.Trace()}
+}
+
+// Bucket is a handle to a key-value bucket.
+type Bucket struct{ raw *kvtypes.Bucket }
+
+// OpenBucket opens (or creates) the named bucket.
+func OpenBucket(name string) (*Bucket, error) {
+	r := kvtypes.BucketOpenBucket(name)
+	if r.IsErr() {
+		return nil, kvError(r.Err())
+	}
+	return &Bucket{raw: r.Ok()}, nil
+}
+
+// Get returns the value stored at key. found is false (with a nil error) when the
+// key is absent.
+func (b *Bucket) Get(key string) (value []byte, found bool, err error) {
+	r := eventual.Get(b.raw, key)
+	if r.IsErr() {
+		return nil, false, kvError(r.Err())
+	}
+	opt := r.Ok()
+	if opt.IsNone() {
+		return nil, false, nil
+	}
+	return consume(opt.Some())
+}
+
+// Set stores value at key.
+func (b *Bucket) Set(key string, value []byte) error {
+	ov, err := outgoing(value)
+	if err != nil {
+		return err
+	}
+	if r := eventual.Set(b.raw, key, ov); r.IsErr() {
+		return kvError(r.Err())
+	}
+	return nil
+}
+
+// Delete removes key (a no-op if it is absent).
+func (b *Bucket) Delete(key string) error {
+	if r := eventual.Delete(b.raw, key); r.IsErr() {
+		return kvError(r.Err())
+	}
+	return nil
+}
+
+// Exists reports whether key is present.
+func (b *Bucket) Exists(key string) (bool, error) {
+	r := eventual.Exists(b.raw, key)
+	if r.IsErr() {
+		return false, kvError(r.Err())
+	}
+	return r.Ok(), nil
+}
+
+// Keys lists all keys in the bucket.
+func (b *Bucket) Keys() ([]string, error) {
+	r := batch.Keys(b.raw)
+	if r.IsErr() {
+		return nil, kvError(r.Err())
+	}
+	return r.Ok(), nil
+}
+
+// GetMany fetches several keys at once, returning a map of only the present keys.
+// The batch is not atomic.
+func (b *Bucket) GetMany(keys []string) (map[string][]byte, error) {
+	r := batch.GetMany(b.raw, keys)
+	if r.IsErr() {
+		return nil, kvError(r.Err())
+	}
+	opts := r.Ok()
+	out := make(map[string][]byte, len(opts))
+	for i, o := range opts {
+		if i >= len(keys) || o.IsNone() {
+			continue
+		}
+		v, _, err := consume(o.Some())
+		if err != nil {
+			return nil, err
+		}
+		out[keys[i]] = v
+	}
+	return out, nil
+}
+
+// SetMany stores several entries at once. The batch is not atomic.
+func (b *Bucket) SetMany(entries map[string][]byte) error {
+	kvs := make([]witTypes.Tuple2[string, *kvtypes.OutgoingValue], 0, len(entries))
+	for k, v := range entries {
+		ov, err := outgoing(v)
+		if err != nil {
+			return err
+		}
+		kvs = append(kvs, witTypes.Tuple2[string, *kvtypes.OutgoingValue]{F0: k, F1: ov})
+	}
+	if r := batch.SetMany(b.raw, kvs); r.IsErr() {
+		return kvError(r.Err())
+	}
+	return nil
+}
+
+// DeleteMany removes several keys at once. The batch is not atomic.
+func (b *Bucket) DeleteMany(keys []string) error {
+	if r := batch.DeleteMany(b.raw, keys); r.IsErr() {
+		return kvError(r.Err())
+	}
+	return nil
+}
+
+func consume(iv *kvtypes.IncomingValue) ([]byte, bool, error) {
+	r := iv.IncomingValueConsumeSync()
+	if r.IsErr() {
+		return nil, false, kvError(r.Err())
+	}
+	return r.Ok(), true, nil
+}
+
+func outgoing(value []byte) (*kvtypes.OutgoingValue, error) {
+	ov := kvtypes.OutgoingValueNewOutgoingValue()
+	if r := ov.OutgoingValueWriteBodySync(value); r.IsErr() {
+		return nil, kvError(r.Err())
+	}
+	return ov, nil
+}
+
+// ── Typed store ───────────────────────────────────────────────────────────────
+
+// Store is a typed view over a [Bucket]: values are JSON-encoded T. Build one with
+// [Typed].
+type Store[T any] struct{ b *Bucket }
+
+// Typed wraps a bucket as a JSON-encoded store of T.
+func Typed[T any](b *Bucket) *Store[T] { return &Store[T]{b: b} }
+
+// Get decodes the value at key as T. found is false (nil error) when absent.
+func (s *Store[T]) Get(key string) (value T, found bool, err error) {
+	raw, found, err := s.b.Get(key)
+	if err != nil || !found {
+		var zero T
+		return zero, found, err
+	}
+	v, err := unmarshalValue[T](raw)
+	if err != nil {
+		var zero T
+		return zero, true, fmt.Errorf("golem/keyvalue: decoding %q: %w", key, err)
+	}
+	return v, true, nil
+}
+
+// Set JSON-encodes value and stores it at key.
+func (s *Store[T]) Set(key string, value T) error {
+	raw, err := marshalValue(value)
+	if err != nil {
+		return fmt.Errorf("golem/keyvalue: encoding %q: %w", key, err)
+	}
+	return s.b.Set(key, raw)
+}
+
+// Delete removes key.
+func (s *Store[T]) Delete(key string) error { return s.b.Delete(key) }
+
+// Exists reports whether key is present.
+func (s *Store[T]) Exists(key string) (bool, error) { return s.b.Exists(key) }
+
+// Keys lists all keys.
+func (s *Store[T]) Keys() ([]string, error) { return s.b.Keys() }
+
+// marshalValue/unmarshalValue are the pure JSON codec used by Store (no host
+// calls), so they are natively testable.
+func marshalValue[T any](v T) ([]byte, error) { return json.Marshal(v) }
+func unmarshalValue[T any](data []byte) (T, error) {
+	var v T
+	err := json.Unmarshal(data, &v)
+	return v, err
+}
diff --git a/sdks/go/golem/keyvalue/keyvalue_test.go b/sdks/go/golem/keyvalue/keyvalue_test.go
new file mode 100644
index 0000000000..b5eda3598c
--- /dev/null
+++ b/sdks/go/golem/keyvalue/keyvalue_test.go
@@ -0,0 +1,51 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 keyvalue
+
+import "testing"
+
+// TestTypedCodecRoundTrip — the pure JSON codec behind Store round-trips a value.
+// (The host-backed Get/Set are exercised by the playground e2e; here we cover the
+// only pure logic — the typed codec.)
+func TestTypedCodecRoundTrip(t *testing.T) {
+	type Cart struct {
+		Items []string
+		Total int64
+	}
+	want := Cart{Items: []string{"a", "b"}, Total: 42}
+
+	raw, err := marshalValue(want)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+	if string(raw) != `{"Items":["a","b"],"Total":42}` {
+		t.Fatalf("encoded = %s", raw)
+	}
+	got, err := unmarshalValue[Cart](raw)
+	if err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	if got.Total != want.Total || len(got.Items) != 2 {
+		t.Fatalf("round-trip = %+v, want %+v", got, want)
+	}
+}
+
+// TestErrorFormatting — the host-error wrapper renders its trace.
+func TestErrorFormatting(t *testing.T) {
+	e := &Error{Trace: "bucket not found"}
+	if e.Error() != "golem/keyvalue: bucket not found" {
+		t.Fatalf("Error() = %q", e.Error())
+	}
+}
diff --git a/sdks/go/golem/log/log.go b/sdks/go/golem/log/log.go
new file mode 100644
index 0000000000..3657f4723c
--- /dev/null
+++ b/sdks/go/golem/log/log.go
@@ -0,0 +1,190 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 log routes Go logging through Golem's structured host logging channel
+// (wasi:logging). Unlike writing to stdout/stderr — which the host records as raw
+// bytes with no level — a wasi:logging record carries a typed level and a context
+// (category) string, so it shows up in worker logs and the oplog with the right
+// severity.
+//
+// The Golem runtime installs this as the default slog handler on agent startup,
+// so ordinary structured logging just works:
+//
+//	slog.Info("charged", "amount", 500)          // -> level=info
+//	slog.Warn("retrying", "attempt", 2)          // -> level=warn
+//	slog.With("area", "billing").Error("declined") // context carries the group
+//
+// (Because Go's slog.SetDefault also bridges the standard log package, plain
+// log.Print output flows here too.) Call [SetDefault] to change the minimum level
+// or base context, [NewHandler] to build a handler yourself, or [Log] for a raw
+// one-shot record.
+package log
+
+import (
+	"context"
+	"io"
+	"log/slog"
+	"strings"
+
+	witlog "github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_logging_logging"
+)
+
+// Level is a wasi:logging severity.
+type Level = witlog.Level
+
+// The severity levels, in increasing order.
+const (
+	Trace    Level = witlog.LevelTrace
+	Debug    Level = witlog.LevelDebug
+	Info     Level = witlog.LevelInfo
+	Warn     Level = witlog.LevelWarn
+	Error    Level = witlog.LevelError
+	Critical Level = witlog.LevelCritical
+)
+
+// Log emits a single record to the host logging channel. context is a free-form
+// category used to group related messages (it may be empty).
+func Log(level Level, context, message string) { witlog.Log(level, context, message) }
+
+// mapLevel maps an slog level onto the wasi:logging severities. slog has no
+// trace/critical by default, so anything below Debug is trace and anything a full
+// step above Error is critical.
+func mapLevel(l slog.Level) Level {
+	switch {
+	case l < slog.LevelDebug:
+		return Trace
+	case l < slog.LevelInfo:
+		return Debug
+	case l < slog.LevelWarn:
+		return Info
+	case l < slog.LevelError:
+		return Warn
+	case l < slog.LevelError+4:
+		return Error
+	default:
+		return Critical
+	}
+}
+
+// formatMessage renders a record as "message key=value …", appending the
+// handler's accumulated attributes and then the record's own. It is pure (no host
+// call) so it is unit-tested directly.
+func formatMessage(base []slog.Attr, r slog.Record) string {
+	var b strings.Builder
+	b.WriteString(r.Message)
+	appendAttr := func(a slog.Attr) bool {
+		if a.Equal(slog.Attr{}) {
+			return true
+		}
+		b.WriteByte(' ')
+		b.WriteString(a.Key)
+		b.WriteByte('=')
+		b.WriteString(a.Value.Resolve().String())
+		return true
+	}
+	for _, a := range base {
+		appendAttr(a)
+	}
+	r.Attrs(appendAttr)
+	return b.String()
+}
+
+// Options configures a [Handler].
+type Options struct {
+	// Level is the minimum level to emit (nil means Info).
+	Level slog.Leveler
+	// Context is the base category string for every record.
+	Context string
+}
+
+// Handler is an [slog.Handler] that writes to the host logging channel. Build one
+// with [NewHandler].
+type Handler struct {
+	leveler slog.Leveler
+	ctx     string
+	attrs   []slog.Attr
+}
+
+// NewHandler builds a handler from opts (nil is fine — Info level, empty context).
+func NewHandler(opts *Options) *Handler {
+	h := &Handler{leveler: slog.LevelInfo}
+	if opts != nil {
+		if opts.Level != nil {
+			h.leveler = opts.Level
+		}
+		h.ctx = opts.Context
+	}
+	return h
+}
+
+// Enabled reports whether a record at l would be emitted.
+func (h *Handler) Enabled(_ context.Context, l slog.Level) bool {
+	return l >= h.leveler.Level()
+}
+
+// Handle emits the record to the host logging channel.
+func (h *Handler) Handle(_ context.Context, r slog.Record) error {
+	Log(mapLevel(r.Level), h.ctx, formatMessage(h.attrs, r))
+	return nil
+}
+
+// WithAttrs returns a handler that prepends attrs to every record.
+func (h *Handler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	if len(attrs) == 0 {
+		return h
+	}
+	nh := *h
+	nh.attrs = append(append([]slog.Attr(nil), h.attrs...), attrs...)
+	return &nh
+}
+
+// WithGroup extends the context (category) with name. slog groups map onto the
+// wasi:logging context, so a grouped logger reads like a named category
+// ("billing/retry") rather than key-prefixing attributes.
+func (h *Handler) WithGroup(name string) slog.Handler {
+	if name == "" {
+		return h
+	}
+	nh := *h
+	if nh.ctx == "" {
+		nh.ctx = name
+	} else {
+		nh.ctx = nh.ctx + "/" + name
+	}
+	return &nh
+}
+
+// SetDefault installs a host-logging handler as slog's default logger (and, via
+// slog, the standard log package). The Golem runtime calls this on startup; call
+// it yourself to override the minimum level or base context.
+func SetDefault(opts *Options) {
+	slog.SetDefault(slog.New(NewHandler(opts)))
+}
+
+// Writer returns an io.Writer whose every write becomes one log record at the
+// given level and context — handy for routing sinks that expect an io.Writer
+// (e.g. a dedicated log.Logger). A trailing newline is trimmed.
+func Writer(level Level, context string) io.Writer {
+	return levelWriter{level: level, ctx: context}
+}
+
+type levelWriter struct {
+	level Level
+	ctx   string
+}
+
+func (w levelWriter) Write(p []byte) (int, error) {
+	Log(w.level, w.ctx, strings.TrimRight(string(p), "\n"))
+	return len(p), nil
+}
diff --git a/sdks/go/golem/log/log_test.go b/sdks/go/golem/log/log_test.go
new file mode 100644
index 0000000000..66f087f6e3
--- /dev/null
+++ b/sdks/go/golem/log/log_test.go
@@ -0,0 +1,108 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 log
+
+import (
+	"context"
+	"log/slog"
+	"testing"
+	"time"
+)
+
+// TestMapLevel — slog levels fold onto the six wasi:logging severities, including
+// the trace/critical ends slog has no named constants for.
+func TestMapLevel(t *testing.T) {
+	cases := []struct {
+		in   slog.Level
+		want Level
+	}{
+		{slog.LevelDebug - 1, Trace},
+		{slog.LevelDebug, Debug},
+		{slog.LevelInfo, Info},
+		{slog.LevelInfo + 1, Info},
+		{slog.LevelWarn, Warn},
+		{slog.LevelError, Error},
+		{slog.LevelError + 3, Error},
+		{slog.LevelError + 4, Critical},
+	}
+	for _, c := range cases {
+		if got := mapLevel(c.in); got != c.want {
+			t.Fatalf("mapLevel(%v) = %d, want %d", c.in, got, c.want)
+		}
+	}
+}
+
+// TestFormatMessage — message plus handler and record attrs render as "k=v".
+func TestFormatMessage(t *testing.T) {
+	r := slog.NewRecord(time.Time{}, slog.LevelInfo, "charged", 0)
+	r.AddAttrs(slog.Int("amount", 500), slog.String("cur", "usd"))
+	base := []slog.Attr{slog.String("area", "billing")}
+	got := formatMessage(base, r)
+	want := "charged area=billing amount=500 cur=usd"
+	if got != want {
+		t.Fatalf("formatMessage = %q, want %q", got, want)
+	}
+
+	// No attrs → just the message.
+	r2 := slog.NewRecord(time.Time{}, slog.LevelWarn, "plain", 0)
+	if got := formatMessage(nil, r2); got != "plain" {
+		t.Fatalf("formatMessage(plain) = %q", got)
+	}
+}
+
+// TestEnabled — the minimum level gates records; nil options default to Info.
+func TestEnabled(t *testing.T) {
+	ctx := context.Background()
+	h := NewHandler(nil)
+	if h.Enabled(ctx, slog.LevelDebug) {
+		t.Fatal("debug should be disabled at default Info")
+	}
+	if !h.Enabled(ctx, slog.LevelInfo) || !h.Enabled(ctx, slog.LevelError) {
+		t.Fatal("info/error should be enabled at default Info")
+	}
+
+	dbg := NewHandler(&Options{Level: slog.LevelDebug})
+	if !dbg.Enabled(ctx, slog.LevelDebug) {
+		t.Fatal("debug should be enabled when min level is Debug")
+	}
+}
+
+// TestWithGroupAndAttrs — WithGroup builds the context path; WithAttrs accumulates.
+func TestWithGroupAndAttrs(t *testing.T) {
+	base := NewHandler(&Options{Context: "app"})
+
+	g := base.WithGroup("billing").(*Handler)
+	if g.ctx != "app/billing" {
+		t.Fatalf("ctx = %q, want app/billing", g.ctx)
+	}
+	g2 := g.WithGroup("retry").(*Handler)
+	if g2.ctx != "app/billing/retry" {
+		t.Fatalf("ctx = %q", g2.ctx)
+	}
+
+	a := g.WithAttrs([]slog.Attr{slog.Int("id", 7)}).(*Handler)
+	if len(a.attrs) != 1 || a.attrs[0].Key != "id" {
+		t.Fatalf("attrs = %+v", a.attrs)
+	}
+	// WithAttrs must not mutate the receiver.
+	if len(g.attrs) != 0 {
+		t.Fatalf("receiver mutated: %+v", g.attrs)
+	}
+
+	// Empty name/attrs are no-ops that return the same handler.
+	if base.WithGroup("") != slog.Handler(base) {
+		t.Fatal("WithGroup(\"\") should return the receiver")
+	}
+}
diff --git a/sdks/go/golem/loginstall_other.go b/sdks/go/golem/loginstall_other.go
new file mode 100644
index 0000000000..1ba4fe9b54
--- /dev/null
+++ b/sdks/go/golem/loginstall_other.go
@@ -0,0 +1,22 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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.
+
+//go:build !wasip1
+
+package golem
+
+// installDefaultLogger is a no-op off the wasm target, so native `go test` links
+// without pulling in the wasi:logging host call. The wasm build (loginstall_wasm.go)
+// installs the real slog handler.
+func installDefaultLogger() {}
diff --git a/sdks/go/golem/loginstall_wasm.go b/sdks/go/golem/loginstall_wasm.go
new file mode 100644
index 0000000000..4fc1ad312b
--- /dev/null
+++ b/sdks/go/golem/loginstall_wasm.go
@@ -0,0 +1,24 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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.
+
+//go:build wasip1
+
+package golem
+
+import golemlog "github.com/golemcloud/golem/sdks/go/golem/log"
+
+// installDefaultLogger routes slog (and, via slog, the standard log package)
+// through the host logging channel. Gated to the wasm target: on native builds
+// the no-op variant is used so `go test` never links the wasi:logging host call.
+func installDefaultLogger() { golemlog.SetDefault(nil) }
diff --git a/sdks/go/golem/marshal.go b/sdks/go/golem/marshal.go
new file mode 100644
index 0000000000..b795e807c5
--- /dev/null
+++ b/sdks/go/golem/marshal.go
@@ -0,0 +1,101 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"fmt"
+	"reflect"
+
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+)
+
+// Values cross the boundary as a schema-value-tree: a flat pool of nodes plus
+// the index of the root. This file holds only the node-level primitives; how a
+// given Go type maps onto them lives in its codec (see codec.go).
+
+// ---------------------------------------------------------------------------
+// encode
+// ---------------------------------------------------------------------------
+
+type valBuilder struct{ nodes []types.SchemaValueNode }
+
+func (b *valBuilder) push(n types.SchemaValueNode) int32 {
+	b.nodes = append(b.nodes, n)
+	return int32(len(b.nodes) - 1)
+}
+
+// encodeWith encodes v using c, producing a complete value tree.
+func encodeWith(c *codec, v reflect.Value) types.SchemaValueTree {
+	var b valBuilder
+	root := c.encode(&b, v)
+	return types.SchemaValueTree{ValueNodes: b.nodes, Root: root}
+}
+
+// encodeParams encodes a parameter list — a record whose fields are the
+// parameters, in declaration order.
+func encodeParams(fields []fieldInfo, v reflect.Value) types.SchemaValueTree {
+	var b valBuilder
+	idxs := make([]int32, 0, len(fields))
+	for _, f := range fields {
+		idxs = append(idxs, f.codec.encode(&b, v.Field(f.index)))
+	}
+	root := b.push(types.MakeSchemaValueNodeRecordValue(idxs))
+	return types.SchemaValueTree{ValueNodes: b.nodes, Root: root}
+}
+
+// ---------------------------------------------------------------------------
+// decode
+// ---------------------------------------------------------------------------
+
+type decoder struct{ nodes []types.SchemaValueNode }
+
+func (d *decoder) node(idx int32) (types.SchemaValueNode, error) {
+	if idx < 0 || int(idx) >= len(d.nodes) {
+		return types.SchemaValueNode{}, fmt.Errorf("value node index %d out of range (%d nodes)", idx, len(d.nodes))
+	}
+	return d.nodes[idx], nil
+}
+
+// decodeParams decodes a parameter-list tree (a record at the root) into dst's
+// fields. An empty parameter list is permitted to arrive as an empty record.
+func decodeParams(tree types.SchemaValueTree, fields []fieldInfo, dst reflect.Value) error {
+	d := decoder{nodes: tree.ValueNodes}
+	if len(d.nodes) == 0 {
+		if len(fields) == 0 {
+			return nil
+		}
+		return fmt.Errorf("empty value tree but %d parameter(s) expected", len(fields))
+	}
+	root, err := d.node(tree.Root)
+	if err != nil {
+		return err
+	}
+	if root.Tag() != types.SchemaValueNodeRecordValue {
+		if len(fields) == 0 {
+			return nil
+		}
+		return fmt.Errorf("expected a record at the root of the parameter list")
+	}
+	idxs := root.RecordValue()
+	if len(idxs) < len(fields) {
+		return fmt.Errorf("parameter list has %d value(s), want %d", len(idxs), len(fields))
+	}
+	for i, f := range fields {
+		if err := f.codec.decode(&d, dst.Field(f.index), idxs[i]); err != nil {
+			return fmt.Errorf("parameter %q: %w", f.name, err)
+		}
+	}
+	return nil
+}
diff --git a/sdks/go/golem/misuse_test.go b/sdks/go/golem/misuse_test.go
new file mode 100644
index 0000000000..a0f24d1f5f
--- /dev/null
+++ b/sdks/go/golem/misuse_test.go
@@ -0,0 +1,178 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"strings"
+	"testing"
+)
+
+// withDefs runs fn against a fresh, fully isolated definition set. Because
+// registration and discovery are both explicit over a *definitions, isolation is
+// just a new instance — no global swapping, no guard, and safe to parallelize.
+func withDefs(t *testing.T, fn func(d *definitions)) {
+	t.Helper()
+	fn(newDefinitions())
+}
+
+// mustDefErr asserts that discovering d surfaces at least one definition error
+// mentioning want (registration- or derivation-phase).
+func mustDefErr(t *testing.T, d *definitions, want string) {
+	t.Helper()
+	_, errs := d.discover()
+	for _, e := range errs {
+		if strings.Contains(e.Error(), want) {
+			return
+		}
+	}
+	t.Fatalf("expected a definition error mentioning %q; got %v", want, errs)
+}
+
+// noDefErrs asserts d discovers cleanly.
+func noDefErrs(t *testing.T, d *definitions) {
+	t.Helper()
+	if _, errs := d.discover(); len(errs) != 0 {
+		t.Fatalf("expected no definition errors, got %v", errs)
+	}
+}
+
+// --- repeated / overwriting settings ---------------------------------------
+
+func TestMisuseRepeatedDesc(t *testing.T) {
+	type Id struct{ Name string }
+	type St struct{}
+	withDefs(t, func(d *definitions) {
+		a := defineAgentInto[Id, St](d, Spec{Name: "A"}, func(Id) *St { return &St{} })
+		m := DefineMethod[Id, Unit, Unit]("m", Desc("a"), Desc("b"))
+		implementInto[Id, St, NoConfig, Unit, Unit](d, a, m, func(*Context[St], Unit) Unit { return Unit{} })
+		mustDefErr(t, d, "Desc set 2 times")
+	})
+}
+
+func TestMisuseRepeatedEndpointAuth(t *testing.T) {
+	e := agent("A", &Mount{Path: "/a/{id}"}, fields("id"),
+		method("m", nil, POST("/x", EndpointAuth(true), EndpointAuth(false))))
+	_, _, errs := buildHTTP(e)
+	if !containsDefErr(errs, "EndpointAuth set 2 times") {
+		t.Fatalf("errs = %v", errs)
+	}
+}
+
+// --- distinct-identity requirements ----------------------------------------
+
+func TestMisuseSharedIdType(t *testing.T) {
+	type SharedID struct{ Name string }
+	type S1 struct{}
+	type S2 struct{}
+	withDefs(t, func(d *definitions) {
+		defineAgentInto[SharedID, S1](d, Spec{Name: "A1"}, func(SharedID) *S1 { return &S1{} })
+		defineAgentInto[SharedID, S2](d, Spec{Name: "A2"}, func(SharedID) *S2 { return &S2{} })
+		mustDefErr(t, d, "already used by agent")
+	})
+}
+
+func TestMisuseDuplicateAgentName(t *testing.T) {
+	type Id1 struct{ A string }
+	type Id2 struct{ B string }
+	type St struct{}
+	withDefs(t, func(d *definitions) {
+		defineAgentInto[Id1, St](d, Spec{Name: "Dup"}, func(Id1) *St { return &St{} })
+		defineAgentInto[Id2, St](d, Spec{Name: "Dup"}, func(Id2) *St { return &St{} })
+		mustDefErr(t, d, "already defined")
+	})
+}
+
+func TestMisuseNonStructId(t *testing.T) {
+	type St struct{}
+	withDefs(t, func(d *definitions) {
+		defineAgentInto[int, St](d, Spec{Name: "A"}, func(int) *St { return &St{} })
+		mustDefErr(t, d, "must be a struct")
+	})
+}
+
+func TestMisuseNilInit(t *testing.T) {
+	type Id struct{ Name string }
+	type St struct{}
+	withDefs(t, func(d *definitions) {
+		defineAgentInto[Id, St](d, Spec{Name: "A"}, nil)
+		mustDefErr(t, d, "non-nil init")
+	})
+}
+
+func TestMisuseNilHandler(t *testing.T) {
+	type Id struct{ Name string }
+	type St struct{}
+	withDefs(t, func(d *definitions) {
+		a := defineAgentInto[Id, St](d, Spec{Name: "A"}, func(Id) *St { return &St{} })
+		implementInto[Id, St, NoConfig, Unit, Unit](d, a, DefineMethod[Id, Unit, Unit]("m"), nil)
+		mustDefErr(t, d, "non-nil handler")
+	})
+}
+
+// --- method-level misuse ----------------------------------------------------
+
+func TestMisuseEmptyMethodName(t *testing.T) {
+	type Id struct{ Name string }
+	type St struct{}
+	withDefs(t, func(d *definitions) {
+		a := defineAgentInto[Id, St](d, Spec{Name: "A"}, func(Id) *St { return &St{} })
+		implementInto[Id, St, NoConfig, Unit, Unit](d, a, DefineMethod[Id, Unit, Unit](""), func(*Context[St], Unit) Unit { return Unit{} })
+		mustDefErr(t, d, "non-empty method name")
+	})
+}
+
+func TestMisuseDuplicateMethod(t *testing.T) {
+	type Id struct{ Name string }
+	type St struct{}
+	withDefs(t, func(d *definitions) {
+		a := defineAgentInto[Id, St](d, Spec{Name: "A"}, func(Id) *St { return &St{} })
+		m := DefineMethod[Id, Unit, Unit]("m")
+		h := func(*Context[St], Unit) Unit { return Unit{} }
+		implementInto[Id, St, NoConfig, Unit, Unit](d, a, m, h)
+		implementInto[Id, St, NoConfig, Unit, Unit](d, a, m, h)
+		mustDefErr(t, d, "already implemented")
+	})
+}
+
+// --- HTTP route collisions --------------------------------------------------
+
+func TestMisuseDuplicateRoute(t *testing.T) {
+	type Id struct{ Name string }
+	type St struct{}
+	type In struct{ X string }
+	withDefs(t, func(d *definitions) {
+		a := defineAgentInto[Id, St](d, Spec{Name: "A", HTTP: &Mount{Path: "/a/{name}"}},
+			func(Id) *St { return &St{} })
+		m1 := DefineMethod[Id, In, Unit]("m1", HTTP(GET("/dup/{x}")))
+		m2 := DefineMethod[Id, In, Unit]("m2", HTTP(GET("/dup/{x}")))
+		implementInto[Id, St, NoConfig, In, Unit](d, a, m1, func(*Context[St], In) Unit { return Unit{} })
+		implementInto[Id, St, NoConfig, In, Unit](d, a, m2, func(*Context[St], In) Unit { return Unit{} })
+		mustDefErr(t, d, "collides")
+	})
+}
+
+// --- variant case type ------------------------------------------------------
+
+type dupTypeVar interface{ dtv() }
+type dupTypeImpl struct{}
+
+func (dupTypeImpl) dtv() {}
+
+func TestMisuseDuplicateCaseType(t *testing.T) {
+	withDefs(t, func(d *definitions) {
+		defineVariantInto[dupTypeVar](d, Case[dupTypeImpl]("a"), Case[dupTypeImpl]("b"))
+		mustDefErr(t, d, "case type")
+	})
+}
diff --git a/sdks/go/golem/named.go b/sdks/go/golem/named.go
new file mode 100644
index 0000000000..d7b33471b0
--- /dev/null
+++ b/sdks/go/golem/named.go
@@ -0,0 +1,60 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import "reflect"
+
+// NameType pins the language-independent `type-id` for T, overriding the id
+// derived from its Go package path and name.
+//
+// A type-id only appears on the wire for a type that becomes a named definition
+// — i.e. a recursive or otherwise ref-shared type (non-recursive types are
+// inlined and carry no id). Cross-language interop requires every SDK to agree
+// on that id for the same logical type; pin it here when the derived
+// `pkg.path.TypeName` would not match the other side:
+//
+//	type Tree struct{ Children []*Tree }
+//	var _ = golem.NameType[Tree]("myapp.tree")
+//
+// Call it from a package-level var so the pin is registered before any agent is
+// compiled. Registering two different ids for the same type, or the same id for
+// two types, panics — an ambiguous id is a wire-compatibility bug, not a
+// tolerable one.
+// Thin wrapper over the package-global defs — keep all logic in [nameTypeInto]
+// so it stays testable against an explicit *definitions. See [defs].
+func NameType[T any](id string) struct{} {
+	return nameTypeInto[T](defs, id)
+}
+
+// nameTypeInto is the instance-scoped implementation behind NameType.
+func nameTypeInto[T any](d *definitions, id string) struct{} {
+	t := reflect.TypeFor[T]()
+	if id == "" {
+		d.recordErr("", "", "NameType[%s] requires a non-empty type-id", t)
+		return struct{}{}
+	}
+	if existing, dup := d.pins[t]; dup && existing != id {
+		d.recordErr("", "", "type %s already pinned to type-id %q", t, existing)
+		return struct{}{}
+	}
+	for other, existing := range d.pins {
+		if existing == id && other != t {
+			d.recordErr("", "", "type-id %q already pinned to %s", id, other)
+			return struct{}{}
+		}
+	}
+	d.pins[t] = id
+	return struct{}{}
+}
diff --git a/sdks/go/golem/promise.go b/sdks/go/golem/promise.go
new file mode 100644
index 0000000000..461ef4e233
--- /dev/null
+++ b/sdks/go/golem/promise.go
@@ -0,0 +1,171 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"encoding/json"
+	"fmt"
+
+	host "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_host"
+	apiHost "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_host"
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+)
+
+// Promises are Golem's durable primitive for human-in-the-loop and asynchronous
+// external integration. An agent creates a promise, hands its [PromiseID] to the
+// outside world, and awaits it; the invocation durably SUSPENDS — surviving
+// restarts, exactly-once via oplog replay — until someone completes it with a
+// payload.
+//
+// Completion can come from another agent ([CompletePromise]) or from off-platform
+// via the worker REST API (POST /:component/workers/:agent/complete with the
+// PromiseID's fields), so the completion payload is arbitrary bytes with no
+// predefined meaning. [Promise] types those bytes as T via JSON, matching the
+// other Golem SDKs: this is a deliberate divergence from the WIT value-tree codec
+// used for RPC params/results ([MethodDef.Call]), because an external completer
+// (a webhook, a curl, a human) can produce JSON but not WIT wire bytes. As an
+// escape hatch, a Promise[[]byte] carries the raw bytes through unchanged.
+
+// PromiseID is the durable, serializable identity of a promise. Hand it to
+// whoever will complete the promise — another agent, or an external system via
+// the worker-service complete endpoint (which needs exactly these three fields).
+// The exported fields make it directly JSON-marshalable.
+type PromiseID struct {
+	// ComponentID is the component the owning agent belongs to.
+	ComponentID UUID
+	// AgentID is the string agent id (agent type + constructor parameters) of the
+	// agent that created the promise — the ":agent" path segment of the REST
+	// complete endpoint.
+	AgentID string
+	// OplogIndex disambiguates promises created by the same agent — the "oplogIdx"
+	// field of the REST complete endpoint.
+	OplogIndex uint64
+}
+
+// String renders a compact, human-readable form (not a parse target).
+func (id PromiseID) String() string {
+	return fmt.Sprintf("%s/%s/%d", id.ComponentID, id.AgentID, id.OplogIndex)
+}
+
+func promiseIDFromWit(w types.PromiseId) PromiseID {
+	return PromiseID{
+		ComponentID: uuidFromWit(w.AgentId.ComponentId.Uuid),
+		AgentID:     w.AgentId.AgentId,
+		OplogIndex:  w.OplogIdx,
+	}
+}
+
+func (id PromiseID) toWit() types.PromiseId {
+	return types.PromiseId{
+		AgentId: types.AgentId{
+			ComponentId: types.ComponentId{Uuid: uuidToWit(id.ComponentID)},
+			AgentId:     id.AgentID,
+		},
+		OplogIdx: id.OplogIndex,
+	}
+}
+
+// Promise is a handle to a durable promise whose completion payload is T. Obtain
+// one with [NewPromise] inside an agent, or rebuild it from a stored id with
+// [PromiseByID]. Only the agent that created the promise may [Promise.Await] it.
+type Promise[T any] struct {
+	id PromiseID
+}
+
+// NewPromise creates a fresh promise owned by the current agent and returns a
+// handle to it. Call it from inside an agent (a method or the constructor); the
+// host mints the id. Persist [Promise.ID] in the agent's state (or send it out)
+// if the promise will be awaited or completed in a later invocation.
+func NewPromise[T any]() *Promise[T] {
+	return &Promise[T]{id: promiseIDFromWit(apiHost.CreatePromise())}
+}
+
+// PromiseByID rebuilds a handle to an existing promise from a stored [PromiseID]
+// — e.g. an id saved in agent state during an earlier invocation, so a later
+// invocation of the same agent can [Promise.Await] it.
+func PromiseByID[T any](id PromiseID) *Promise[T] {
+	return &Promise[T]{id: id}
+}
+
+// ID returns the durable identity of the promise, to persist or hand to a
+// completer.
+func (p *Promise[T]) ID() PromiseID { return p.id }
+
+// Await blocks until the promise is completed and returns the payload decoded as
+// T (JSON, or the raw bytes when T is []byte). It durably SUSPENDS the invocation
+// — the worker may be evicted and resumed, and on replay the recorded payload is
+// returned from the oplog (exactly-once). Like [Future.Get] it is fail-loud: an
+// infra failure traps and surfaces as an agent-error rather than returning an
+// error value.
+//
+// Only the agent that created the promise may Await it; awaiting from another
+// agent traps in the host.
+func (p *Promise[T]) Await() T {
+	res := apiHost.GetPromise(p.id.toWit())
+	data := res.Get()
+	res.Drop()
+	return decodePromisePayload[T](data)
+}
+
+// WebhookURL mints an external URL that completes this promise: a POST to the URL
+// completes the promise with the request body, so a later [Promise.Await] returns
+// that body decoded as T (JSON, or the raw bytes when T is []byte). Hand the URL
+// to an off-platform system to drive a webhook-style callback.
+//
+// It requires the agent type to be currently deployed behind an HTTP API (set
+// [Spec].HTTP on the agent and declare the agent in the manifest's httpApi
+// deployment) — it is fail-loud: the runtime traps, surfacing an agent-error, if
+// the agent is not http-api-deployed, or if a different agent type created the
+// promise. Typically called once per promise.
+func (p *Promise[T]) WebhookURL() string {
+	return host.CreateWebhook(p.id.toWit())
+}
+
+// CompletePromise completes the promise identified by id, from within any agent
+// (agent-to-agent completion; external completers use the REST endpoint instead).
+// The value is encoded as the payload (JSON, or raw bytes when T is []byte).
+//
+// It returns true if this call completed the promise, false if it was already
+// completed — the idempotency signal from the host. It is fail-loud only on an
+// infra/encode failure.
+func CompletePromise[T any](id PromiseID, value T) bool {
+	return apiHost.CompletePromise(id.toWit(), encodePromisePayload(value))
+}
+
+// encodePromisePayload serializes a promise payload: raw pass-through when T is
+// exactly []byte (so non-JSON external payloads round-trip), otherwise JSON.
+// Pure (no host import), so it is natively testable.
+func encodePromisePayload[T any](v T) []byte {
+	if b, ok := any(v).([]byte); ok {
+		return b
+	}
+	b, err := json.Marshal(v)
+	if err != nil {
+		panic(fmt.Errorf("golem: encoding promise payload: %w", err))
+	}
+	return b
+}
+
+// decodePromisePayload is the inverse of [encodePromisePayload].
+func decodePromisePayload[T any](data []byte) T {
+	var out T
+	if _, ok := any(out).([]byte); ok {
+		return any(data).(T)
+	}
+	if err := json.Unmarshal(data, &out); err != nil {
+		panic(fmt.Errorf("golem: decoding promise payload: %w", err))
+	}
+	return out
+}
diff --git a/sdks/go/golem/promise_test.go b/sdks/go/golem/promise_test.go
new file mode 100644
index 0000000000..225d7ceb71
--- /dev/null
+++ b/sdks/go/golem/promise_test.go
@@ -0,0 +1,101 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"bytes"
+	"testing"
+
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+)
+
+// TestPromisePayloadJSON — a non-[]byte payload round-trips as JSON.
+func TestPromisePayloadJSON(t *testing.T) {
+	type Decision struct {
+		Approved bool
+		By       string
+	}
+	want := Decision{Approved: true, By: "alice"}
+
+	data := encodePromisePayload(want)
+	if string(data) != `{"Approved":true,"By":"alice"}` {
+		t.Fatalf("encoded JSON = %s", data)
+	}
+	if got := decodePromisePayload[Decision](data); got != want {
+		t.Fatalf("round-trip = %+v, want %+v", got, want)
+	}
+}
+
+// TestPromisePayloadRawBytes — a []byte payload passes through verbatim (NOT
+// base64-wrapped as json.Marshal would), so non-JSON external payloads survive.
+func TestPromisePayloadRawBytes(t *testing.T) {
+	raw := []byte{0x00, 0x01, 0xff, 'h', 'i'}
+
+	data := encodePromisePayload(raw)
+	if !bytes.Equal(data, raw) {
+		t.Fatalf("[]byte should pass through raw, got %v", data)
+	}
+	if got := decodePromisePayload[[]byte](data); !bytes.Equal(got, raw) {
+		t.Fatalf("[]byte round-trip = %v, want %v", got, raw)
+	}
+}
+
+// TestPromisePayloadNamedBytesUsesJSON — the pass-through is for []byte exactly;
+// a named type with []byte underlying still goes through JSON.
+func TestPromisePayloadNamedBytesUsesJSON(t *testing.T) {
+	type Raw []byte
+	if got := encodePromisePayload(Raw("hi")); string(got) != `"aGk="` {
+		t.Fatalf("named []byte should JSON-encode (base64), got %s", got)
+	}
+}
+
+// TestPromiseIDRoundTrip — PromiseID survives conversion to the host wire form
+// and back, and String() renders the component/agent/oplog form.
+func TestPromiseIDRoundTrip(t *testing.T) {
+	id := PromiseID{
+		ComponentID: UUID{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+		AgentID:     "Approval(\"order-7\")",
+		OplogIndex:  42,
+	}
+
+	got := promiseIDFromWit(id.toWit())
+	if got != id {
+		t.Fatalf("round-trip = %+v, want %+v", got, id)
+	}
+
+	want := "00010203-0405-0607-0809-0a0b0c0d0e0f/Approval(\"order-7\")/42"
+	if id.String() != want {
+		t.Fatalf("String() = %q, want %q", id.String(), want)
+	}
+}
+
+// TestPromiseIDFromWit — decoding a host PromiseId maps every nested field.
+func TestPromiseIDFromWit(t *testing.T) {
+	w := types.PromiseId{
+		AgentId: types.AgentId{
+			ComponentId: types.ComponentId{Uuid: types.Uuid{HighBits: 0x0001020304050607, LowBits: 0x08090a0b0c0d0e0f}},
+			AgentId:     "Shop(\"acme\")",
+		},
+		OplogIdx: 99,
+	}
+
+	id := promiseIDFromWit(w)
+	if id.AgentID != "Shop(\"acme\")" || id.OplogIndex != 99 {
+		t.Fatalf("agent/oplog not mapped: %+v", id)
+	}
+	if id.ComponentID != (UUID{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}) {
+		t.Fatalf("component uuid not mapped: %v", id.ComponentID)
+	}
+}
diff --git a/sdks/go/golem/rdbms/mysql/mysql.go b/sdks/go/golem/rdbms/mysql/mysql.go
new file mode 100644
index 0000000000..ea5951b46f
--- /dev/null
+++ b/sdks/go/golem/rdbms/mysql/mysql.go
@@ -0,0 +1,986 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 mysql is a Go wrapper over Golem's durable MySQL client (golem:rdbms).
+// It mirrors the postgres package — open a connection with a URL, then run
+// parametrised statements in a database/sql-flavoured style:
+//
+//	db, err := mysql.Open("mysql://user:pass@host:3306/app")
+//	rs, err := db.Query("SELECT id, name FROM users WHERE active = ?", true)
+//	for _, row := range rs.Rows() {
+//	    var id int64
+//	    var name string
+//	    row.Scan(&id, &name)
+//	}
+//
+// Parameters are ordinary Go values: nil, bool, the signed and unsigned int
+// widths, float32/float64, string, []byte and [time.Time] map to the natural
+// MySQL types. Where the exact column type matters (decimal, a specific integer
+// width, json, enum) build the value with a constructor in this package
+// ([Decimal], [Int], [JSON], …), which returns a [DbValue] you pass like any
+// other argument. Columns are read positionally with the typed getters on [Row]
+// ([Row.Int64], [Row.String], …), the generic [Row.Get], or [Row.Scan].
+//
+// Like the other WASI wrappers, operations return an error, distinct from the
+// fail-loud control-flow surface. The connection is durable — every
+// query/execute/commit is journaled and replayed — and because these are remote
+// side effects, using it inside a read-only method traps. Unlike postgres, MySQL
+// has no recursive value families, so every value maps to a Go value.
+//
+// Pair a fallible call with golem.Must / golem.Must0 / golem.Must2 to abort the
+// invocation on error.
+package mysql
+
+import (
+	"fmt"
+	"time"
+
+	my "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_rdbms_mysql"
+	"github.com/golemcloud/golem/sdks/go/golem/rdbms/types"
+)
+
+// ── Errors ──────────────────────────────────────────────────────────────────
+
+// ErrorKind classifies an [Error]. It is shared with the postgres driver via
+// [types.ErrorKind].
+type ErrorKind = types.ErrorKind
+
+// The error kinds (see [types] for docs).
+const (
+	ConnectionFailure     = types.ConnectionFailure
+	QueryParameterFailure = types.QueryParameterFailure
+	QueryExecutionFailure = types.QueryExecutionFailure
+	QueryResponseFailure  = types.QueryResponseFailure
+	Other                 = types.Other
+)
+
+// Error is a MySQL host error.
+type Error struct {
+	Kind    ErrorKind
+	Message string
+}
+
+func (e *Error) Error() string { return "golem/rdbms/mysql: " + e.Message }
+
+func myError(e my.Error) error {
+	switch e.Tag() {
+	case my.ErrorConnectionFailure:
+		return &Error{Kind: ConnectionFailure, Message: e.ConnectionFailure()}
+	case my.ErrorQueryParameterFailure:
+		return &Error{Kind: QueryParameterFailure, Message: e.QueryParameterFailure()}
+	case my.ErrorQueryExecutionFailure:
+		return &Error{Kind: QueryExecutionFailure, Message: e.QueryExecutionFailure()}
+	case my.ErrorQueryResponseFailure:
+		return &Error{Kind: QueryResponseFailure, Message: e.QueryResponseFailure()}
+	default:
+		return &Error{Kind: Other, Message: e.Other()}
+	}
+}
+
+// ── DbValue (typed parameters + opaque escape hatch) ─────────────────────────
+
+// DbValue is a MySQL value whose exact column type is chosen explicitly, rather
+// than inferred from a Go value. Build one with a constructor in this package
+// ([Decimal], [Int], [JSON], …) and pass it as a query argument. A value read
+// back from a column family this wrapper does not recognize is also returned as
+// a DbValue; inspect its family with [DbValue.Kind].
+type DbValue struct{ raw my.DbValue }
+
+// tagName gives a db-value family its display name (used by [DbValue.Kind] and
+// error text — never by encode/decode). It switches on the generated constants,
+// not on the raw tag position, so a reordered or inserted WIT case still names
+// correctly and a renamed or removed one fails to compile here. A newly appended
+// WIT case shows as "unknown(N)" and is handled as an opaque [DbValue] (see the
+// default in decodeValue) until a case and name are added below.
+func tagName(tag uint8) string {
+	switch tag {
+	case my.DbValueBoolean:
+		return "boolean"
+	case my.DbValueTinyint:
+		return "tinyint"
+	case my.DbValueSmallint:
+		return "smallint"
+	case my.DbValueMediumint:
+		return "mediumint"
+	case my.DbValueInt:
+		return "int"
+	case my.DbValueBigint:
+		return "bigint"
+	case my.DbValueTinyintUnsigned:
+		return "tinyint-unsigned"
+	case my.DbValueSmallintUnsigned:
+		return "smallint-unsigned"
+	case my.DbValueMediumintUnsigned:
+		return "mediumint-unsigned"
+	case my.DbValueIntUnsigned:
+		return "int-unsigned"
+	case my.DbValueBigintUnsigned:
+		return "bigint-unsigned"
+	case my.DbValueFloat:
+		return "float"
+	case my.DbValueDouble:
+		return "double"
+	case my.DbValueDecimal:
+		return "decimal"
+	case my.DbValueDate:
+		return "date"
+	case my.DbValueDatetime:
+		return "datetime"
+	case my.DbValueTimestamp:
+		return "timestamp"
+	case my.DbValueTime:
+		return "time"
+	case my.DbValueYear:
+		return "year"
+	case my.DbValueFixchar:
+		return "fixchar"
+	case my.DbValueVarchar:
+		return "varchar"
+	case my.DbValueTinytext:
+		return "tinytext"
+	case my.DbValueText:
+		return "text"
+	case my.DbValueMediumtext:
+		return "mediumtext"
+	case my.DbValueLongtext:
+		return "longtext"
+	case my.DbValueBinary:
+		return "binary"
+	case my.DbValueVarbinary:
+		return "varbinary"
+	case my.DbValueTinyblob:
+		return "tinyblob"
+	case my.DbValueBlob:
+		return "blob"
+	case my.DbValueMediumblob:
+		return "mediumblob"
+	case my.DbValueLongblob:
+		return "longblob"
+	case my.DbValueEnumeration:
+		return "enumeration"
+	case my.DbValueSet:
+		return "set"
+	case my.DbValueBit:
+		return "bit"
+	case my.DbValueJson:
+		return "json"
+	case my.DbValueNull:
+		return "null"
+	default:
+		return fmt.Sprintf("unknown(%d)", tag)
+	}
+}
+
+// Kind returns the name of the value's MySQL type family (for example "decimal"
+// or "bigint-unsigned").
+func (v DbValue) Kind() string { return tagName(v.raw.Tag()) }
+
+// IsNull reports whether the value is SQL NULL.
+func (v DbValue) IsNull() bool { return v.raw.Tag() == my.DbValueNull }
+
+func (v DbValue) String() string { return "mysql:" + v.Kind() }
+
+// Null builds a SQL NULL parameter.
+func Null() DbValue { return DbValue{my.MakeDbValueNull()} }
+
+// Boolean builds a boolean parameter.
+func Boolean(v bool) DbValue { return DbValue{my.MakeDbValueBoolean(v)} }
+
+// Tinyint builds a signed tinyint parameter.
+func Tinyint(v int8) DbValue { return DbValue{my.MakeDbValueTinyint(v)} }
+
+// Smallint builds a signed smallint parameter.
+func Smallint(v int16) DbValue { return DbValue{my.MakeDbValueSmallint(v)} }
+
+// Mediumint builds a signed mediumint parameter.
+func Mediumint(v int32) DbValue { return DbValue{my.MakeDbValueMediumint(v)} }
+
+// Int builds a signed int parameter.
+func Int(v int32) DbValue { return DbValue{my.MakeDbValueInt(v)} }
+
+// Bigint builds a signed bigint parameter.
+func Bigint(v int64) DbValue { return DbValue{my.MakeDbValueBigint(v)} }
+
+// TinyintUnsigned builds an unsigned tinyint parameter.
+func TinyintUnsigned(v uint8) DbValue { return DbValue{my.MakeDbValueTinyintUnsigned(v)} }
+
+// SmallintUnsigned builds an unsigned smallint parameter.
+func SmallintUnsigned(v uint16) DbValue { return DbValue{my.MakeDbValueSmallintUnsigned(v)} }
+
+// MediumintUnsigned builds an unsigned mediumint parameter.
+func MediumintUnsigned(v uint32) DbValue { return DbValue{my.MakeDbValueMediumintUnsigned(v)} }
+
+// IntUnsigned builds an unsigned int parameter.
+func IntUnsigned(v uint32) DbValue { return DbValue{my.MakeDbValueIntUnsigned(v)} }
+
+// BigintUnsigned builds an unsigned bigint parameter.
+func BigintUnsigned(v uint64) DbValue { return DbValue{my.MakeDbValueBigintUnsigned(v)} }
+
+// Float builds a single-precision float parameter.
+func Float(v float32) DbValue { return DbValue{my.MakeDbValueFloat(v)} }
+
+// Double builds a double-precision float parameter.
+func Double(v float64) DbValue { return DbValue{my.MakeDbValueDouble(v)} }
+
+// Decimal builds an exact decimal parameter from its string form (so no
+// precision is lost).
+func Decimal(v string) DbValue { return DbValue{my.MakeDbValueDecimal(v)} }
+
+// Year builds a year parameter.
+func Year(v uint16) DbValue { return DbValue{my.MakeDbValueYear(v)} }
+
+// Fixchar builds a fixed-length char parameter.
+func Fixchar(v string) DbValue { return DbValue{my.MakeDbValueFixchar(v)} }
+
+// Varchar builds a varchar parameter.
+func Varchar(v string) DbValue { return DbValue{my.MakeDbValueVarchar(v)} }
+
+// Tinytext builds a tinytext parameter.
+func Tinytext(v string) DbValue { return DbValue{my.MakeDbValueTinytext(v)} }
+
+// Text builds a text parameter.
+func Text(v string) DbValue { return DbValue{my.MakeDbValueText(v)} }
+
+// Mediumtext builds a mediumtext parameter.
+func Mediumtext(v string) DbValue { return DbValue{my.MakeDbValueMediumtext(v)} }
+
+// Longtext builds a longtext parameter.
+func Longtext(v string) DbValue { return DbValue{my.MakeDbValueLongtext(v)} }
+
+// Binary builds a fixed-length binary parameter.
+func Binary(v []byte) DbValue { return DbValue{my.MakeDbValueBinary(v)} }
+
+// Varbinary builds a varbinary parameter.
+func Varbinary(v []byte) DbValue { return DbValue{my.MakeDbValueVarbinary(v)} }
+
+// Tinyblob builds a tinyblob parameter.
+func Tinyblob(v []byte) DbValue { return DbValue{my.MakeDbValueTinyblob(v)} }
+
+// Blob builds a blob parameter.
+func Blob(v []byte) DbValue { return DbValue{my.MakeDbValueBlob(v)} }
+
+// Mediumblob builds a mediumblob parameter.
+func Mediumblob(v []byte) DbValue { return DbValue{my.MakeDbValueMediumblob(v)} }
+
+// Longblob builds a longblob parameter.
+func Longblob(v []byte) DbValue { return DbValue{my.MakeDbValueLongblob(v)} }
+
+// Enumeration builds an enum parameter (the selected label).
+func Enumeration(v string) DbValue { return DbValue{my.MakeDbValueEnumeration(v)} }
+
+// Set builds a set parameter (the comma-separated labels).
+func Set(v string) DbValue { return DbValue{my.MakeDbValueSet(v)} }
+
+// Bit builds a bit-string parameter.
+func Bit(v []bool) DbValue { return DbValue{my.MakeDbValueBit(v)} }
+
+// JSON builds a json parameter from its serialized text.
+func JSON(v string) DbValue { return DbValue{my.MakeDbValueJson(v)} }
+
+// Date builds a date parameter.
+func Date(d types.Date) DbValue {
+	return DbValue{my.MakeDbValueDate(my.Date{Year: int32(d.Year), Month: uint8(d.Month), Day: uint8(d.Day)})}
+}
+
+// Datetime builds a datetime parameter.
+func Datetime(ts types.Timestamp) DbValue {
+	return DbValue{my.MakeDbValueDatetime(typesTimestampToWit(ts))}
+}
+
+// Timestamp builds a timestamp parameter.
+func Timestamp(ts types.Timestamp) DbValue {
+	return DbValue{my.MakeDbValueTimestamp(typesTimestampToWit(ts))}
+}
+
+// Time builds a time-of-day parameter.
+func Time(t types.Time) DbValue { return DbValue{my.MakeDbValueTime(typesTimeToWit(t))} }
+
+// ── Parameter encoding ───────────────────────────────────────────────────────
+
+func encodeParam(v any) (my.DbValue, error) {
+	switch x := v.(type) {
+	case nil:
+		return my.MakeDbValueNull(), nil
+	case DbValue:
+		return x.raw, nil
+	case bool:
+		return my.MakeDbValueBoolean(x), nil
+	case int:
+		return my.MakeDbValueBigint(int64(x)), nil
+	case int64:
+		return my.MakeDbValueBigint(x), nil
+	case int32:
+		return my.MakeDbValueInt(x), nil
+	case int16:
+		return my.MakeDbValueSmallint(x), nil
+	case int8:
+		return my.MakeDbValueTinyint(x), nil
+	case uint:
+		return my.MakeDbValueBigintUnsigned(uint64(x)), nil
+	case uint64:
+		return my.MakeDbValueBigintUnsigned(x), nil
+	case uint32:
+		return my.MakeDbValueIntUnsigned(x), nil
+	case uint16:
+		return my.MakeDbValueSmallintUnsigned(x), nil
+	case uint8:
+		return my.MakeDbValueTinyintUnsigned(x), nil
+	case float64:
+		return my.MakeDbValueDouble(x), nil
+	case float32:
+		return my.MakeDbValueFloat(x), nil
+	case string:
+		return my.MakeDbValueVarchar(x), nil
+	case []byte:
+		return my.MakeDbValueBlob(x), nil
+	case time.Time:
+		return my.MakeDbValueDatetime(goTimeToTimestamp(x)), nil
+	default:
+		return my.DbValue{}, fmt.Errorf("unsupported parameter type %T; wrap it with a mysql.* constructor", v)
+	}
+}
+
+func encodeParams(args []any) ([]my.DbValue, error) {
+	if len(args) == 0 {
+		return nil, nil
+	}
+	out := make([]my.DbValue, len(args))
+	for i, a := range args {
+		v, err := encodeParam(a)
+		if err != nil {
+			return nil, fmt.Errorf("golem/rdbms/mysql: parameter %d: %w", i+1, err)
+		}
+		out[i] = v
+	}
+	return out, nil
+}
+
+// ── Value decoding ────────────────────────────────────────────────────────────
+
+func decodeValue(v my.DbValue) any {
+	switch v.Tag() {
+	case my.DbValueNull:
+		return nil
+	case my.DbValueBoolean:
+		return v.Boolean()
+	case my.DbValueTinyint:
+		return v.Tinyint()
+	case my.DbValueSmallint:
+		return v.Smallint()
+	case my.DbValueMediumint:
+		return v.Mediumint()
+	case my.DbValueInt:
+		return v.Int()
+	case my.DbValueBigint:
+		return v.Bigint()
+	case my.DbValueTinyintUnsigned:
+		return v.TinyintUnsigned()
+	case my.DbValueSmallintUnsigned:
+		return v.SmallintUnsigned()
+	case my.DbValueMediumintUnsigned:
+		return v.MediumintUnsigned()
+	case my.DbValueIntUnsigned:
+		return v.IntUnsigned()
+	case my.DbValueBigintUnsigned:
+		return v.BigintUnsigned()
+	case my.DbValueFloat:
+		return v.Float()
+	case my.DbValueDouble:
+		return v.Double()
+	case my.DbValueDecimal:
+		return v.Decimal()
+	case my.DbValueDate:
+		return dateToGoTime(v.Date())
+	case my.DbValueDatetime:
+		return timestampToGoTime(v.Datetime())
+	case my.DbValueTimestamp:
+		return timestampToGoTime(v.Timestamp())
+	case my.DbValueTime:
+		return witTimeToTypes(v.Time())
+	case my.DbValueYear:
+		return v.Year()
+	case my.DbValueFixchar:
+		return v.Fixchar()
+	case my.DbValueVarchar:
+		return v.Varchar()
+	case my.DbValueTinytext:
+		return v.Tinytext()
+	case my.DbValueText:
+		return v.Text()
+	case my.DbValueMediumtext:
+		return v.Mediumtext()
+	case my.DbValueLongtext:
+		return v.Longtext()
+	case my.DbValueBinary:
+		return v.Binary()
+	case my.DbValueVarbinary:
+		return v.Varbinary()
+	case my.DbValueTinyblob:
+		return v.Tinyblob()
+	case my.DbValueBlob:
+		return v.Blob()
+	case my.DbValueMediumblob:
+		return v.Mediumblob()
+	case my.DbValueLongblob:
+		return v.Longblob()
+	case my.DbValueEnumeration:
+		return v.Enumeration()
+	case my.DbValueSet:
+		return v.Set()
+	case my.DbValueBit:
+		return v.Bit()
+	case my.DbValueJson:
+		return v.Json()
+	default:
+		return DbValue{raw: v}
+	}
+}
+
+// ── Temporal conversions ──────────────────────────────────────────────────────
+
+func goTimeToTimestamp(t time.Time) my.Timestamp {
+	return my.Timestamp{
+		Date: my.Date{Year: int32(t.Year()), Month: uint8(t.Month()), Day: uint8(t.Day())},
+		Time: my.Time{Hour: uint8(t.Hour()), Minute: uint8(t.Minute()), Second: uint8(t.Second()), Nanosecond: uint32(t.Nanosecond())},
+	}
+}
+
+func timestampToGoTime(ts my.Timestamp) time.Time {
+	return time.Date(int(ts.Date.Year), time.Month(ts.Date.Month), int(ts.Date.Day),
+		int(ts.Time.Hour), int(ts.Time.Minute), int(ts.Time.Second), int(ts.Time.Nanosecond), time.UTC)
+}
+
+func dateToGoTime(d my.Date) time.Time {
+	return time.Date(int(d.Year), time.Month(d.Month), int(d.Day), 0, 0, 0, 0, time.UTC)
+}
+
+func witTimeToTypes(t my.Time) types.Time {
+	return types.Time{Hour: int(t.Hour), Minute: int(t.Minute), Second: int(t.Second), Nanosecond: int(t.Nanosecond)}
+}
+
+func typesTimeToWit(t types.Time) my.Time {
+	return my.Time{Hour: uint8(t.Hour), Minute: uint8(t.Minute), Second: uint8(t.Second), Nanosecond: uint32(t.Nanosecond)}
+}
+
+func typesTimestampToWit(ts types.Timestamp) my.Timestamp {
+	return my.Timestamp{
+		Date: my.Date{Year: int32(ts.Date.Year), Month: uint8(ts.Date.Month), Day: uint8(ts.Date.Day)},
+		Time: typesTimeToWit(ts.Time),
+	}
+}
+
+// ── Rows / columns / result sets ─────────────────────────────────────────────
+
+// Column describes a result column.
+type Column struct {
+	Ordinal    uint64
+	Name       string
+	DbTypeName string
+}
+
+func convColumns(cols []my.DbColumn) []Column {
+	out := make([]Column, len(cols))
+	for i, c := range cols {
+		out[i] = Column{Ordinal: c.Ordinal, Name: c.Name, DbTypeName: c.DbTypeName}
+	}
+	return out
+}
+
+// Row is a single result row, read positionally.
+type Row struct{ values []my.DbValue }
+
+// Len returns the number of columns in the row.
+func (r Row) Len() int { return len(r.values) }
+
+func (r Row) at(i int) (my.DbValue, error) {
+	if i < 0 || i >= len(r.values) {
+		return my.DbValue{}, fmt.Errorf("golem/rdbms/mysql: column index %d out of range (%d columns)", i, len(r.values))
+	}
+	return r.values[i], nil
+}
+
+func typeErr(i int, v my.DbValue, want string) error {
+	return fmt.Errorf("golem/rdbms/mysql: column %d is %s, not %s", i, tagName(v.Tag()), want)
+}
+
+// IsNull reports whether column i is SQL NULL.
+func (r Row) IsNull(i int) bool {
+	v, err := r.at(i)
+	return err == nil && v.Tag() == my.DbValueNull
+}
+
+// Get decodes column i to a Go value: bool, the signed/unsigned int widths,
+// float32/float64, string, []byte, [time.Time] and the [types] structs for the
+// families that map cleanly, nil for NULL, or an opaque [DbValue] otherwise.
+func (r Row) Get(i int) (any, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return nil, err
+	}
+	return decodeValue(v), nil
+}
+
+// Int64 reads an integer column (any signed or unsigned width, or year) as int64.
+// A bigint-unsigned above math.MaxInt64 wraps; use [Row.Uint64] for those.
+func (r Row) Int64(i int) (int64, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return 0, err
+	}
+	switch v.Tag() {
+	case my.DbValueTinyint:
+		return int64(v.Tinyint()), nil
+	case my.DbValueSmallint:
+		return int64(v.Smallint()), nil
+	case my.DbValueMediumint:
+		return int64(v.Mediumint()), nil
+	case my.DbValueInt:
+		return int64(v.Int()), nil
+	case my.DbValueBigint:
+		return v.Bigint(), nil
+	case my.DbValueTinyintUnsigned:
+		return int64(v.TinyintUnsigned()), nil
+	case my.DbValueSmallintUnsigned:
+		return int64(v.SmallintUnsigned()), nil
+	case my.DbValueMediumintUnsigned:
+		return int64(v.MediumintUnsigned()), nil
+	case my.DbValueIntUnsigned:
+		return int64(v.IntUnsigned()), nil
+	case my.DbValueBigintUnsigned:
+		return int64(v.BigintUnsigned()), nil
+	case my.DbValueYear:
+		return int64(v.Year()), nil
+	default:
+		return 0, typeErr(i, v, "int64")
+	}
+}
+
+// Uint64 reads an unsigned integer column (any unsigned width, or year) as uint64.
+func (r Row) Uint64(i int) (uint64, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return 0, err
+	}
+	switch v.Tag() {
+	case my.DbValueTinyintUnsigned:
+		return uint64(v.TinyintUnsigned()), nil
+	case my.DbValueSmallintUnsigned:
+		return uint64(v.SmallintUnsigned()), nil
+	case my.DbValueMediumintUnsigned:
+		return uint64(v.MediumintUnsigned()), nil
+	case my.DbValueIntUnsigned:
+		return uint64(v.IntUnsigned()), nil
+	case my.DbValueBigintUnsigned:
+		return v.BigintUnsigned(), nil
+	case my.DbValueYear:
+		return uint64(v.Year()), nil
+	default:
+		return 0, typeErr(i, v, "uint64")
+	}
+}
+
+// Float64 reads a float or double column as float64.
+func (r Row) Float64(i int) (float64, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return 0, err
+	}
+	switch v.Tag() {
+	case my.DbValueDouble:
+		return v.Double(), nil
+	case my.DbValueFloat:
+		return float64(v.Float()), nil
+	default:
+		return 0, typeErr(i, v, "float64")
+	}
+}
+
+// String reads a textual column (the char/text families, decimal, json, enum or
+// set) as a string.
+func (r Row) String(i int) (string, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return "", err
+	}
+	switch v.Tag() {
+	case my.DbValueFixchar:
+		return v.Fixchar(), nil
+	case my.DbValueVarchar:
+		return v.Varchar(), nil
+	case my.DbValueTinytext:
+		return v.Tinytext(), nil
+	case my.DbValueText:
+		return v.Text(), nil
+	case my.DbValueMediumtext:
+		return v.Mediumtext(), nil
+	case my.DbValueLongtext:
+		return v.Longtext(), nil
+	case my.DbValueDecimal:
+		return v.Decimal(), nil
+	case my.DbValueJson:
+		return v.Json(), nil
+	case my.DbValueEnumeration:
+		return v.Enumeration(), nil
+	case my.DbValueSet:
+		return v.Set(), nil
+	default:
+		return "", typeErr(i, v, "string")
+	}
+}
+
+// Bool reads a boolean column.
+func (r Row) Bool(i int) (bool, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return false, err
+	}
+	if v.Tag() != my.DbValueBoolean {
+		return false, typeErr(i, v, "bool")
+	}
+	return v.Boolean(), nil
+}
+
+// Bytes reads a binary or blob column.
+func (r Row) Bytes(i int) ([]byte, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return nil, err
+	}
+	switch v.Tag() {
+	case my.DbValueBinary:
+		return v.Binary(), nil
+	case my.DbValueVarbinary:
+		return v.Varbinary(), nil
+	case my.DbValueTinyblob:
+		return v.Tinyblob(), nil
+	case my.DbValueBlob:
+		return v.Blob(), nil
+	case my.DbValueMediumblob:
+		return v.Mediumblob(), nil
+	case my.DbValueLongblob:
+		return v.Longblob(), nil
+	default:
+		return nil, typeErr(i, v, "bytes")
+	}
+}
+
+// Time reads a date, datetime or timestamp column as a [time.Time] (in UTC).
+func (r Row) Time(i int) (time.Time, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return time.Time{}, err
+	}
+	switch v.Tag() {
+	case my.DbValueDate:
+		return dateToGoTime(v.Date()), nil
+	case my.DbValueDatetime:
+		return timestampToGoTime(v.Datetime()), nil
+	case my.DbValueTimestamp:
+		return timestampToGoTime(v.Timestamp()), nil
+	default:
+		return time.Time{}, typeErr(i, v, "time.Time")
+	}
+}
+
+// Scan decodes the row into the given pointers, one per column. Supported
+// destinations are *int64, *int, *uint64, *float64, *string, *bool, *[]byte,
+// *time.Time and *any (which receives whatever [Row.Get] returns).
+func (r Row) Scan(dest ...any) error {
+	if len(dest) != len(r.values) {
+		return fmt.Errorf("golem/rdbms/mysql: Scan: %d destination(s) for %d column(s)", len(dest), len(r.values))
+	}
+	for i, d := range dest {
+		if err := r.scanOne(i, d); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (r Row) scanOne(i int, d any) error {
+	switch p := d.(type) {
+	case *any:
+		v, err := r.Get(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	case *int64:
+		v, err := r.Int64(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	case *int:
+		v, err := r.Int64(i)
+		if err != nil {
+			return err
+		}
+		*p = int(v)
+	case *uint64:
+		v, err := r.Uint64(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	case *float64:
+		v, err := r.Float64(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	case *string:
+		v, err := r.String(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	case *bool:
+		v, err := r.Bool(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	case *[]byte:
+		v, err := r.Bytes(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	case *time.Time:
+		v, err := r.Time(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	default:
+		return fmt.Errorf("golem/rdbms/mysql: Scan: unsupported destination type %T for column %d", d, i)
+	}
+	return nil
+}
+
+// ResultSet is the eager result of a [DB.Query] / [Tx.Query]: all columns and
+// rows, already fetched.
+type ResultSet struct {
+	columns []Column
+	rows    []Row
+}
+
+func newResultSet(res my.DbResult) *ResultSet {
+	rows := make([]Row, len(res.Rows))
+	for i, r := range res.Rows {
+		rows[i] = Row{values: r.Values}
+	}
+	return &ResultSet{columns: convColumns(res.Columns), rows: rows}
+}
+
+// Columns returns the result column metadata.
+func (rs *ResultSet) Columns() []Column { return rs.columns }
+
+// Rows returns the result rows.
+func (rs *ResultSet) Rows() []Row { return rs.rows }
+
+// ── Streaming results ─────────────────────────────────────────────────────────
+
+// Stream is a cursor over a [DB.QueryStream] / [Tx.QueryStream] result. Iterate
+// with [Stream.Next] until it reports no more rows, then call [Stream.Close].
+type Stream struct {
+	raw  *my.DbResultStream
+	cols []Column
+	buf  []Row
+	idx  int
+	done bool
+}
+
+// Columns returns the result column metadata.
+func (s *Stream) Columns() []Column {
+	if s.cols == nil {
+		s.cols = convColumns(s.raw.GetColumns())
+	}
+	return s.cols
+}
+
+// Next returns the next row. ok is false (with a nil error) once the stream is
+// exhausted.
+func (s *Stream) Next() (row Row, ok bool, err error) {
+	for s.idx >= len(s.buf) {
+		if s.done {
+			return Row{}, false, nil
+		}
+		opt := s.raw.GetNext()
+		if opt.IsNone() {
+			s.done = true
+			return Row{}, false, nil
+		}
+		batch := opt.Some()
+		s.buf = make([]Row, len(batch))
+		for i, r := range batch {
+			s.buf[i] = Row{values: r.Values}
+		}
+		s.idx = 0
+	}
+	row = s.buf[s.idx]
+	s.idx++
+	return row, true, nil
+}
+
+// Close releases the stream.
+func (s *Stream) Close() { s.raw.Drop() }
+
+// ── Connection ────────────────────────────────────────────────────────────────
+
+// DB is an open MySQL connection.
+type DB struct{ raw *my.DbConnection }
+
+// Open opens a connection to the given MySQL URL
+// ("mysql://user:pass@host:port/database").
+func Open(address string) (*DB, error) {
+	r := my.DbConnectionOpen(address)
+	if r.IsErr() {
+		return nil, myError(r.Err())
+	}
+	return &DB{raw: r.Ok()}, nil
+}
+
+// Query runs a statement that returns rows.
+func (db *DB) Query(sql string, args ...any) (*ResultSet, error) {
+	params, err := encodeParams(args)
+	if err != nil {
+		return nil, err
+	}
+	r := db.raw.Query(sql, params)
+	if r.IsErr() {
+		return nil, myError(r.Err())
+	}
+	return newResultSet(r.Ok()), nil
+}
+
+// Exec runs a statement that does not return rows, returning the number of
+// affected rows.
+func (db *DB) Exec(sql string, args ...any) (uint64, error) {
+	params, err := encodeParams(args)
+	if err != nil {
+		return 0, err
+	}
+	r := db.raw.Execute(sql, params)
+	if r.IsErr() {
+		return 0, myError(r.Err())
+	}
+	return r.Ok(), nil
+}
+
+// QueryStream runs a row-returning statement and streams the results.
+func (db *DB) QueryStream(sql string, args ...any) (*Stream, error) {
+	params, err := encodeParams(args)
+	if err != nil {
+		return nil, err
+	}
+	r := db.raw.QueryStream(sql, params)
+	if r.IsErr() {
+		return nil, myError(r.Err())
+	}
+	return &Stream{raw: r.Ok()}, nil
+}
+
+// Begin starts a transaction.
+func (db *DB) Begin() (*Tx, error) {
+	r := db.raw.BeginTransaction()
+	if r.IsErr() {
+		return nil, myError(r.Err())
+	}
+	return &Tx{raw: r.Ok()}, nil
+}
+
+// Transaction runs fn inside a transaction, committing if fn returns nil and
+// rolling back (and returning fn's error) otherwise.
+func (db *DB) Transaction(fn func(*Tx) error) error {
+	tx, err := db.Begin()
+	if err != nil {
+		return err
+	}
+	if err := fn(tx); err != nil {
+		_ = tx.Rollback()
+		return err
+	}
+	return tx.Commit()
+}
+
+// Close releases the connection.
+func (db *DB) Close() { db.raw.Drop() }
+
+// ── Transactions ──────────────────────────────────────────────────────────────
+
+// Tx is an in-progress transaction. Finish it with [Tx.Commit] or [Tx.Rollback].
+type Tx struct{ raw *my.DbTransaction }
+
+// Query runs a row-returning statement in the transaction.
+func (tx *Tx) Query(sql string, args ...any) (*ResultSet, error) {
+	params, err := encodeParams(args)
+	if err != nil {
+		return nil, err
+	}
+	r := tx.raw.Query(sql, params)
+	if r.IsErr() {
+		return nil, myError(r.Err())
+	}
+	return newResultSet(r.Ok()), nil
+}
+
+// Exec runs a non-row-returning statement in the transaction, returning the
+// number of affected rows.
+func (tx *Tx) Exec(sql string, args ...any) (uint64, error) {
+	params, err := encodeParams(args)
+	if err != nil {
+		return 0, err
+	}
+	r := tx.raw.Execute(sql, params)
+	if r.IsErr() {
+		return 0, myError(r.Err())
+	}
+	return r.Ok(), nil
+}
+
+// QueryStream runs a row-returning statement in the transaction and streams the
+// results.
+func (tx *Tx) QueryStream(sql string, args ...any) (*Stream, error) {
+	params, err := encodeParams(args)
+	if err != nil {
+		return nil, err
+	}
+	r := tx.raw.QueryStream(sql, params)
+	if r.IsErr() {
+		return nil, myError(r.Err())
+	}
+	return &Stream{raw: r.Ok()}, nil
+}
+
+// Commit commits the transaction.
+func (tx *Tx) Commit() error {
+	r := tx.raw.Commit()
+	tx.raw.Drop()
+	if r.IsErr() {
+		return myError(r.Err())
+	}
+	return nil
+}
+
+// Rollback aborts the transaction.
+func (tx *Tx) Rollback() error {
+	r := tx.raw.Rollback()
+	tx.raw.Drop()
+	if r.IsErr() {
+		return myError(r.Err())
+	}
+	return nil
+}
diff --git a/sdks/go/golem/rdbms/mysql/mysql_test.go b/sdks/go/golem/rdbms/mysql/mysql_test.go
new file mode 100644
index 0000000000..800a304747
--- /dev/null
+++ b/sdks/go/golem/rdbms/mysql/mysql_test.go
@@ -0,0 +1,230 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 mysql
+
+import (
+	"testing"
+	"time"
+
+	my "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_rdbms_mysql"
+	"github.com/golemcloud/golem/sdks/go/golem/rdbms/types"
+)
+
+// TestEncodeParamTags — each Go value coerces to the expected db-value family,
+// including the signed/unsigned integer split MySQL supports natively.
+func TestEncodeParamTags(t *testing.T) {
+	cases := []struct {
+		in   any
+		want uint8
+	}{
+		{nil, my.DbValueNull},
+		{true, my.DbValueBoolean},
+		{int(1), my.DbValueBigint},
+		{int64(1), my.DbValueBigint},
+		{int32(1), my.DbValueInt},
+		{int16(1), my.DbValueSmallint},
+		{int8(1), my.DbValueTinyint},
+		{uint(1), my.DbValueBigintUnsigned},
+		{uint64(1), my.DbValueBigintUnsigned},
+		{uint32(1), my.DbValueIntUnsigned},
+		{uint16(1), my.DbValueSmallintUnsigned},
+		{uint8(1), my.DbValueTinyintUnsigned},
+		{float64(1), my.DbValueDouble},
+		{float32(1), my.DbValueFloat},
+		{"s", my.DbValueVarchar},
+		{[]byte{1}, my.DbValueBlob},
+		{time.Now().UTC(), my.DbValueDatetime},
+		{Decimal("1.5"), my.DbValueDecimal},
+		{JSON(`{}`), my.DbValueJson},
+		{Year(2026), my.DbValueYear},
+	}
+	for _, c := range cases {
+		v, err := encodeParam(c.in)
+		if err != nil {
+			t.Fatalf("encodeParam(%T) error: %v", c.in, err)
+		}
+		if v.Tag() != c.want {
+			t.Fatalf("encodeParam(%T) tag = %s, want %s", c.in, tagName(v.Tag()), tagName(c.want))
+		}
+	}
+}
+
+// TestEncodeParamUnsupported — an unhandled type is a clear error, not a panic.
+func TestEncodeParamUnsupported(t *testing.T) {
+	if _, err := encodeParam(struct{ X int }{}); err == nil {
+		t.Fatal("expected error for unsupported type")
+	}
+}
+
+// TestTypedGetters — typed getters read the matching families and reject others.
+func TestTypedGetters(t *testing.T) {
+	r := Row{values: []my.DbValue{
+		my.MakeDbValueBigint(42),
+		my.MakeDbValueDouble(3.5),
+		my.MakeDbValueVarchar("hello"),
+		my.MakeDbValueBoolean(true),
+		my.MakeDbValueBlob([]byte{1, 2, 3}),
+		my.MakeDbValueNull(),
+	}}
+
+	if got, err := r.Int64(0); err != nil || got != 42 {
+		t.Fatalf("Int64 = %d, %v", got, err)
+	}
+	if got, err := r.Float64(1); err != nil || got != 3.5 {
+		t.Fatalf("Float64 = %v, %v", got, err)
+	}
+	if got, err := r.String(2); err != nil || got != "hello" {
+		t.Fatalf("String = %q, %v", got, err)
+	}
+	if got, err := r.Bool(3); err != nil || !got {
+		t.Fatalf("Bool = %v, %v", got, err)
+	}
+	if got, err := r.Bytes(4); err != nil || len(got) != 3 || got[2] != 3 {
+		t.Fatalf("Bytes = %v, %v", got, err)
+	}
+	if !r.IsNull(5) {
+		t.Fatal("column 5 should be null")
+	}
+	if _, err := r.Int64(2); err == nil {
+		t.Fatal("Int64 on varchar should error")
+	}
+	if _, err := r.Int64(99); err == nil {
+		t.Fatal("Int64 out of range should error")
+	}
+}
+
+// TestUnsignedGetters — unsigned families read through Int64 and Uint64.
+func TestUnsignedGetters(t *testing.T) {
+	big := uint64(1) << 63 // above math.MaxInt64
+	r := Row{values: []my.DbValue{
+		my.MakeDbValueIntUnsigned(7),
+		my.MakeDbValueBigintUnsigned(big),
+		my.MakeDbValueYear(2026),
+	}}
+	if got, err := r.Uint64(1); err != nil || got != big {
+		t.Fatalf("Uint64(bigint-unsigned) = %d, %v", got, err)
+	}
+	if got, err := r.Int64(0); err != nil || got != 7 {
+		t.Fatalf("Int64(int-unsigned) = %d, %v", got, err)
+	}
+	if got, err := r.Uint64(2); err != nil || got != 2026 {
+		t.Fatalf("Uint64(year) = %d, %v", got, err)
+	}
+}
+
+// TestScan — Scan fills typed destinations positionally, including *uint64 and *any.
+func TestScan(t *testing.T) {
+	r := Row{values: []my.DbValue{
+		my.MakeDbValueBigint(7),
+		my.MakeDbValueVarchar("name"),
+		my.MakeDbValueBigintUnsigned(9),
+	}}
+	var id int64
+	var name string
+	var u uint64
+	if err := r.Scan(&id, &name, &u); err != nil {
+		t.Fatalf("Scan error: %v", err)
+	}
+	if id != 7 || name != "name" || u != 9 {
+		t.Fatalf("Scan = %d %q %d", id, name, u)
+	}
+
+	var anyVal any
+	if err := r.Scan(&anyVal, new(string), new(uint64)); err != nil {
+		t.Fatalf("Scan into *any error: %v", err)
+	}
+	if anyVal.(int64) != 7 {
+		t.Fatalf("*any = %v", anyVal)
+	}
+
+	if err := r.Scan(&id); err == nil {
+		t.Fatal("Scan with wrong count should error")
+	}
+}
+
+// TestDecodeValue — decode maps each family to the expected Go type.
+func TestDecodeValue(t *testing.T) {
+	if v := decodeValue(my.MakeDbValueNull()); v != nil {
+		t.Fatalf("null = %v", v)
+	}
+	if v := decodeValue(my.MakeDbValueInt(5)); v.(int32) != 5 {
+		t.Fatalf("int = %v", v)
+	}
+	if v := decodeValue(my.MakeDbValueBigintUnsigned(9)); v.(uint64) != 9 {
+		t.Fatalf("bigint-unsigned = %v", v)
+	}
+	if v := decodeValue(my.MakeDbValueDecimal("1.25")); v.(string) != "1.25" {
+		t.Fatalf("decimal = %v", v)
+	}
+	if v := decodeValue(my.MakeDbValueYear(2026)); v.(uint16) != 2026 {
+		t.Fatalf("year = %v", v)
+	}
+	if v := decodeValue(my.MakeDbValueSet("a,b")); v.(string) != "a,b" {
+		t.Fatalf("set = %v", v)
+	}
+}
+
+// TestTimeRoundTrip — time.Time survives the datetime encode/decode (UTC).
+func TestTimeRoundTrip(t *testing.T) {
+	orig := time.Date(2026, 7, 30, 12, 34, 56, 0, time.UTC)
+	got := timestampToGoTime(goTimeToTimestamp(orig))
+	if !got.Equal(orig) {
+		t.Fatalf("datetime round-trip = %v, want %v", got, orig)
+	}
+	tm := decodeValue(my.MakeDbValueTime(my.Time{Hour: 1, Minute: 2, Second: 3, Nanosecond: 4})).(types.Time)
+	if tm.Hour != 1 || tm.Minute != 2 || tm.Second != 3 || tm.Nanosecond != 4 {
+		t.Fatalf("time = %+v", tm)
+	}
+}
+
+// TestTagName — display names key on the generated constants, with a diagnosable fallback.
+func TestTagName(t *testing.T) {
+	cases := []struct {
+		tag  uint8
+		want string
+	}{
+		{my.DbValueBoolean, "boolean"},
+		{my.DbValueBigintUnsigned, "bigint-unsigned"},
+		{my.DbValueDecimal, "decimal"},
+		{my.DbValueJson, "json"},
+		{200, "unknown(200)"},
+	}
+	for _, c := range cases {
+		if got := tagName(c.tag); got != c.want {
+			t.Fatalf("tagName(%d) = %q, want %q", c.tag, got, c.want)
+		}
+	}
+}
+
+// TestErrorMapping — each host error variant maps to the right kind/message.
+func TestErrorMapping(t *testing.T) {
+	cases := []struct {
+		raw  my.Error
+		kind ErrorKind
+		msg  string
+	}{
+		{my.MakeErrorConnectionFailure("c"), ConnectionFailure, "c"},
+		{my.MakeErrorQueryParameterFailure("p"), QueryParameterFailure, "p"},
+		{my.MakeErrorQueryExecutionFailure("e"), QueryExecutionFailure, "e"},
+		{my.MakeErrorQueryResponseFailure("r"), QueryResponseFailure, "r"},
+		{my.MakeErrorOther("o"), Other, "o"},
+	}
+	for _, c := range cases {
+		err := myError(c.raw).(*Error)
+		if err.Kind != c.kind || err.Message != c.msg {
+			t.Fatalf("mapping = kind %d msg %q, want kind %d msg %q", err.Kind, err.Message, c.kind, c.msg)
+		}
+	}
+}
diff --git a/sdks/go/golem/rdbms/postgres/postgres.go b/sdks/go/golem/rdbms/postgres/postgres.go
new file mode 100644
index 0000000000..ee492e807b
--- /dev/null
+++ b/sdks/go/golem/rdbms/postgres/postgres.go
@@ -0,0 +1,1608 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 postgres is a Go wrapper over Golem's durable Postgres client
+// (golem:rdbms). Open a connection with a URL, then run parametrised statements
+// in a database/sql-flavoured style:
+//
+//	db, err := postgres.Open("postgres://user:pass@host:5432/app")
+//	rs, err := db.Query("SELECT id, name FROM users WHERE active = $1", true)
+//	for _, row := range rs.Rows() {
+//	    var id int64
+//	    var name string
+//	    row.Scan(&id, &name)
+//	}
+//
+// Parameters are ordinary Go values: nil, bool, the int/float widths, string,
+// []byte, [uuid.UUID] and [time.Time] map to the natural Postgres types.
+// Anything else — or a value whose exact Postgres type matters (numeric, jsonb,
+// a specific integer width) — is built with the constructors in this package
+// ([Numeric], [JSONB], [Int4], …), which return a [DbValue] you pass just like
+// any other argument. Columns are read back positionally with the typed getters
+// on [Row] ([Row.Int64], [Row.String], …), the generic [Row.Get], or [Row.Scan].
+//
+// Like the other WASI wrappers, operations return an error, distinct from the
+// fail-loud control-flow surface. The connection is durable — every
+// query/execute/commit is journaled and replayed — and because these are remote
+// side effects, using it inside a read-only method traps.
+//
+// Every value family maps to a Go value: the common types (ints, floats, text,
+// json, uuid, temporal, inet/cidr/macaddr, bit strings, vectors) and the
+// composite families (arrays, composites, domains, ranges) through their typed
+// [Row] getters and matching constructors.
+//
+// Pair a fallible call with golem.Must / golem.Must0 / golem.Must2 to abort the
+// invocation on error.
+package postgres
+
+import (
+	"encoding/binary"
+	"fmt"
+	"net/netip"
+	"time"
+
+	pg "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_rdbms_postgres"
+	rtypes "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_rdbms_types"
+	"github.com/golemcloud/golem/sdks/go/golem/rdbms/types"
+	"github.com/golemcloud/golem/sdks/go/golem/uuid"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// ── Errors ──────────────────────────────────────────────────────────────────
+
+// ErrorKind classifies an [Error]. It is shared with the mysql driver via
+// [types.ErrorKind].
+type ErrorKind = types.ErrorKind
+
+// The error kinds (see [types] for docs).
+const (
+	ConnectionFailure     = types.ConnectionFailure
+	QueryParameterFailure = types.QueryParameterFailure
+	QueryExecutionFailure = types.QueryExecutionFailure
+	QueryResponseFailure  = types.QueryResponseFailure
+	Other                 = types.Other
+)
+
+// Error is a Postgres host error.
+type Error struct {
+	Kind    ErrorKind
+	Message string
+}
+
+func (e *Error) Error() string { return "golem/rdbms/postgres: " + e.Message }
+
+func pgError(e pg.Error) error {
+	switch e.Tag() {
+	case pg.ErrorConnectionFailure:
+		return &Error{Kind: ConnectionFailure, Message: e.ConnectionFailure()}
+	case pg.ErrorQueryParameterFailure:
+		return &Error{Kind: QueryParameterFailure, Message: e.QueryParameterFailure()}
+	case pg.ErrorQueryExecutionFailure:
+		return &Error{Kind: QueryExecutionFailure, Message: e.QueryExecutionFailure()}
+	case pg.ErrorQueryResponseFailure:
+		return &Error{Kind: QueryResponseFailure, Message: e.QueryResponseFailure()}
+	default:
+		return &Error{Kind: Other, Message: e.Other()}
+	}
+}
+
+// ── DbValue (typed parameters) ───────────────────────────────────────────────
+
+// DbValue is a Postgres value whose exact column type is chosen explicitly,
+// rather than inferred from a Go value. Build one with a constructor in this
+// package ([Numeric], [JSONB], [Int4], [Array], [Composite], …) and pass it as a
+// query argument.
+//
+// A DbValue holds either a ready value (the flat constructors) or a deferred
+// encoder (the recursive [Array]/[Composite]/[Domain]/[CustomRange], whose host
+// resources are built only when the parameter is actually sent — so construction
+// stays side-effect free and a bad element surfaces as a normal parameter error).
+type DbValue struct {
+	raw    pg.DbValue
+	encode func() (pg.DbValue, error)
+}
+
+func flat(v pg.DbValue) DbValue { return DbValue{raw: v} }
+
+// tagName gives a db-value family its display name (used in error text — never by
+// encode/decode). It switches on the generated constants, not on the raw tag
+// position, so a reordered or inserted WIT case still names correctly and a
+// renamed or removed one fails to compile here. A newly appended WIT case shows
+// as "unknown(N)" until a case and name are added below.
+func tagName(tag uint8) string {
+	switch tag {
+	case pg.DbValueCharacter:
+		return "character"
+	case pg.DbValueInt2:
+		return "int2"
+	case pg.DbValueInt4:
+		return "int4"
+	case pg.DbValueInt8:
+		return "int8"
+	case pg.DbValueFloat4:
+		return "float4"
+	case pg.DbValueFloat8:
+		return "float8"
+	case pg.DbValueNumeric:
+		return "numeric"
+	case pg.DbValueBoolean:
+		return "boolean"
+	case pg.DbValueText:
+		return "text"
+	case pg.DbValueVarchar:
+		return "varchar"
+	case pg.DbValueBpchar:
+		return "bpchar"
+	case pg.DbValueTimestamp:
+		return "timestamp"
+	case pg.DbValueTimestamptz:
+		return "timestamptz"
+	case pg.DbValueDate:
+		return "date"
+	case pg.DbValueTime:
+		return "time"
+	case pg.DbValueTimetz:
+		return "timetz"
+	case pg.DbValueInterval:
+		return "interval"
+	case pg.DbValueBytea:
+		return "bytea"
+	case pg.DbValueJson:
+		return "json"
+	case pg.DbValueJsonb:
+		return "jsonb"
+	case pg.DbValueJsonpath:
+		return "jsonpath"
+	case pg.DbValueXml:
+		return "xml"
+	case pg.DbValueUuid:
+		return "uuid"
+	case pg.DbValueInet:
+		return "inet"
+	case pg.DbValueCidr:
+		return "cidr"
+	case pg.DbValueMacaddr:
+		return "macaddr"
+	case pg.DbValueBit:
+		return "bit"
+	case pg.DbValueVarbit:
+		return "varbit"
+	case pg.DbValueInt4range:
+		return "int4range"
+	case pg.DbValueInt8range:
+		return "int8range"
+	case pg.DbValueNumrange:
+		return "numrange"
+	case pg.DbValueTsrange:
+		return "tsrange"
+	case pg.DbValueTstzrange:
+		return "tstzrange"
+	case pg.DbValueDaterange:
+		return "daterange"
+	case pg.DbValueMoney:
+		return "money"
+	case pg.DbValueOid:
+		return "oid"
+	case pg.DbValueEnumeration:
+		return "enumeration"
+	case pg.DbValueComposite:
+		return "composite"
+	case pg.DbValueDomain:
+		return "domain"
+	case pg.DbValueArray:
+		return "array"
+	case pg.DbValueRange:
+		return "range"
+	case pg.DbValueNull:
+		return "null"
+	case pg.DbValueVector:
+		return "vector"
+	case pg.DbValueHalfvec:
+		return "halfvec"
+	case pg.DbValueSparsevec:
+		return "sparsevec"
+	default:
+		return fmt.Sprintf("unknown(%d)", tag)
+	}
+}
+
+// Null builds a SQL NULL parameter.
+func Null() DbValue { return flat(pg.MakeDbValueNull()) }
+
+// Char builds a Postgres "char" (single-byte integer) parameter.
+func Char(v int8) DbValue { return flat(pg.MakeDbValueCharacter(v)) }
+
+// Int2 builds a smallint parameter.
+func Int2(v int16) DbValue { return flat(pg.MakeDbValueInt2(v)) }
+
+// Int4 builds an integer parameter.
+func Int4(v int32) DbValue { return flat(pg.MakeDbValueInt4(v)) }
+
+// Int8 builds a bigint parameter.
+func Int8(v int64) DbValue { return flat(pg.MakeDbValueInt8(v)) }
+
+// Float4 builds a real parameter.
+func Float4(v float32) DbValue { return flat(pg.MakeDbValueFloat4(v)) }
+
+// Float8 builds a double precision parameter.
+func Float8(v float64) DbValue { return flat(pg.MakeDbValueFloat8(v)) }
+
+// Numeric builds an exact numeric/decimal parameter from its string form (so no
+// precision is lost).
+func Numeric(v string) DbValue { return flat(pg.MakeDbValueNumeric(v)) }
+
+// Money builds a money parameter (value in the smallest currency unit).
+func Money(v int64) DbValue { return flat(pg.MakeDbValueMoney(v)) }
+
+// Oid builds an object identifier parameter.
+func Oid(v uint32) DbValue { return flat(pg.MakeDbValueOid(v)) }
+
+// Varchar builds a varchar parameter.
+func Varchar(v string) DbValue { return flat(pg.MakeDbValueVarchar(v)) }
+
+// Bpchar builds a blank-padded char parameter.
+func Bpchar(v string) DbValue { return flat(pg.MakeDbValueBpchar(v)) }
+
+// JSON builds a json parameter from its serialized text.
+func JSON(v string) DbValue { return flat(pg.MakeDbValueJson(v)) }
+
+// JSONB builds a jsonb parameter from its serialized text.
+func JSONB(v string) DbValue { return flat(pg.MakeDbValueJsonb(v)) }
+
+// JSONPath builds a jsonpath parameter.
+func JSONPath(v string) DbValue { return flat(pg.MakeDbValueJsonpath(v)) }
+
+// XML builds an xml parameter.
+func XML(v string) DbValue { return flat(pg.MakeDbValueXml(v)) }
+
+// Bit builds a fixed-length bit-string parameter.
+func Bit(v []bool) DbValue { return flat(pg.MakeDbValueBit(v)) }
+
+// Varbit builds a varying bit-string parameter.
+func Varbit(v []bool) DbValue { return flat(pg.MakeDbValueVarbit(v)) }
+
+// Inet builds an inet (host address) parameter.
+func Inet(a netip.Addr) DbValue { return flat(pg.MakeDbValueInet(ipToWit(a))) }
+
+// Cidr builds a cidr (network address) parameter.
+func Cidr(a netip.Addr) DbValue { return flat(pg.MakeDbValueCidr(ipToWit(a))) }
+
+// Macaddr builds a macaddr parameter.
+func Macaddr(m types.MacAddr) DbValue { return flat(pg.MakeDbValueMacaddr(macToWit(m))) }
+
+// Interval builds an interval parameter.
+func Interval(iv types.Interval) DbValue {
+	return flat(pg.MakeDbValueInterval(pg.Interval{
+		Months: int32(iv.Months), Days: int32(iv.Days), Microseconds: iv.Microseconds,
+	}))
+}
+
+// Date builds a date parameter.
+func Date(d types.Date) DbValue {
+	return flat(pg.MakeDbValueDate(pg.Date{Year: int32(d.Year), Month: uint8(d.Month), Day: uint8(d.Day)}))
+}
+
+// Time builds a time-of-day parameter.
+func Time(t types.Time) DbValue { return flat(pg.MakeDbValueTime(typesTimeToWit(t))) }
+
+// Timetz builds a time-of-day-with-offset parameter.
+func Timetz(t types.Timetz) DbValue {
+	return flat(pg.MakeDbValueTimetz(pg.Timetz{Time: typesTimeToWit(t.Time), Offset: int32(t.OffsetSeconds)}))
+}
+
+// Timestamp builds a timestamp (no time zone) parameter.
+func Timestamp(ts types.Timestamp) DbValue {
+	return flat(pg.MakeDbValueTimestamp(typesTimestampToWit(ts)))
+}
+
+// Timestamptz builds a timestamp-with-time-zone parameter.
+func Timestamptz(ts types.Timestamptz) DbValue {
+	return flat(pg.MakeDbValueTimestamptz(pg.Timestamptz{
+		Timestamp: typesTimestampToWit(ts.Timestamp), Offset: int32(ts.OffsetSeconds),
+	}))
+}
+
+// Vector builds a pgvector vector parameter.
+func Vector(v []float32) DbValue { return flat(pg.MakeDbValueVector(v)) }
+
+// Halfvec builds a pgvector halfvec parameter.
+func Halfvec(v []float32) DbValue { return flat(pg.MakeDbValueHalfvec(v)) }
+
+// Enumeration builds an enum parameter carrying the enum type name and the
+// selected label.
+func Enumeration(name, value string) DbValue {
+	return flat(pg.MakeDbValueEnumeration(pg.Enumeration{Name: name, Value: value}))
+}
+
+// SparseVector builds a pgvector sparse-vector parameter.
+func SparseVector(v SparseVec) DbValue {
+	return flat(pg.MakeDbValueSparsevec(pg.SparseVec{Dim: int32(v.Dim), Indices: v.Indices, Values: v.Values}))
+}
+
+// ── Ranges ────────────────────────────────────────────────────────────────────
+
+// BoundKind is the kind of a range [Bound].
+type BoundKind uint8
+
+const (
+	// BoundUnbounded is an open end (-infinity / +infinity).
+	BoundUnbounded BoundKind = iota
+	// BoundIncluded is a closed end (the value is part of the range).
+	BoundIncluded
+	// BoundExcluded is an open end (the value is not part of the range).
+	BoundExcluded
+)
+
+// Bound is one end of a [Range].
+type Bound[T any] struct {
+	Kind  BoundKind
+	Value T // ignored when Kind is BoundUnbounded
+}
+
+// Included builds a closed bound.
+func Included[T any](v T) Bound[T] { return Bound[T]{Kind: BoundIncluded, Value: v} }
+
+// Excluded builds an open bound.
+func Excluded[T any](v T) Bound[T] { return Bound[T]{Kind: BoundExcluded, Value: v} }
+
+// Unbounded builds an infinite bound.
+func Unbounded[T any]() Bound[T] { return Bound[T]{Kind: BoundUnbounded} }
+
+// Range is a range value with a typed start and end.
+type Range[T any] struct {
+	Start Bound[T]
+	End   Bound[T]
+}
+
+// Int4Range builds an int4range parameter. Reads back as Range[int32].
+func Int4Range(r Range[int32]) DbValue {
+	return flat(pg.MakeDbValueInt4range(pg.Int4range{Start: int4BoundToWit(r.Start), End: int4BoundToWit(r.End)}))
+}
+
+// Int8Range builds an int8range parameter. Reads back as Range[int64].
+func Int8Range(r Range[int64]) DbValue {
+	return flat(pg.MakeDbValueInt8range(pg.Int8range{Start: int8BoundToWit(r.Start), End: int8BoundToWit(r.End)}))
+}
+
+// NumRange builds a numrange parameter (bounds as numeric strings). Reads back as Range[string].
+func NumRange(r Range[string]) DbValue {
+	return flat(pg.MakeDbValueNumrange(pg.Numrange{Start: numBoundToWit(r.Start), End: numBoundToWit(r.End)}))
+}
+
+// TsRange builds a tsrange parameter. Reads back as Range[time.Time] (UTC).
+func TsRange(r Range[time.Time]) DbValue {
+	return flat(pg.MakeDbValueTsrange(pg.Tsrange{Start: tsBoundToWit(r.Start), End: tsBoundToWit(r.End)}))
+}
+
+// TstzRange builds a tstzrange parameter. Reads back as Range[time.Time] (offset preserved).
+func TstzRange(r Range[time.Time]) DbValue {
+	return flat(pg.MakeDbValueTstzrange(pg.Tstzrange{Start: tstzBoundToWit(r.Start), End: tstzBoundToWit(r.End)}))
+}
+
+// DateRange builds a daterange parameter. Reads back as Range[time.Time] (UTC, date only).
+func DateRange(r Range[time.Time]) DbValue {
+	return flat(pg.MakeDbValueDaterange(pg.Daterange{Start: dateBoundToWit(r.Start), End: dateBoundToWit(r.End)}))
+}
+
+// ── Recursive families (arrays, composites, domains, custom ranges) ──────────
+//
+// These are backed by host lazy-value resources built when the parameter is sent,
+// so their constructors defer the work into DbValue.encode.
+
+// Array builds an array parameter from elements, each an ordinary Go value or a
+// nested [DbValue]. Reads back as []any.
+func Array(elems ...any) DbValue {
+	return DbValue{encode: func() (pg.DbValue, error) {
+		lazies := make([]*pg.LazyDbValue, len(elems))
+		for i, e := range elems {
+			ev, err := encodeParam(e)
+			if err != nil {
+				return pg.DbValue{}, fmt.Errorf("array element %d: %w", i+1, err)
+			}
+			lazies[i] = pg.MakeLazyDbValue(ev)
+		}
+		return pg.MakeDbValueArray(lazies), nil
+	}}
+}
+
+// Composite builds a composite (row) parameter of the named type with the given
+// ordered field values. Reads back as [CompositeValue].
+func Composite(name string, fields ...any) DbValue {
+	return DbValue{encode: func() (pg.DbValue, error) {
+		vals := make([]*pg.LazyDbValue, len(fields))
+		for i, f := range fields {
+			fv, err := encodeParam(f)
+			if err != nil {
+				return pg.DbValue{}, fmt.Errorf("composite field %d: %w", i+1, err)
+			}
+			vals[i] = pg.MakeLazyDbValue(fv)
+		}
+		return pg.MakeDbValueComposite(pg.Composite{Name: name, Values: vals}), nil
+	}}
+}
+
+// Domain builds a domain parameter of the named type wrapping value. Reads back
+// as [DomainValue].
+func Domain(name string, value any) DbValue {
+	return DbValue{encode: func() (pg.DbValue, error) {
+		v, err := encodeParam(value)
+		if err != nil {
+			return pg.DbValue{}, fmt.Errorf("domain value: %w", err)
+		}
+		return pg.MakeDbValueDomain(pg.Domain{Name: name, Value: pg.MakeLazyDbValue(v)}), nil
+	}}
+}
+
+// CustomRange builds a value of a user-defined range type (name) with arbitrary
+// element bounds. Reads back as [RangeValue]. Use the typed [Int4Range] etc. for
+// the built-in range types.
+func CustomRange(name string, start, end Bound[any]) DbValue {
+	return DbValue{encode: func() (pg.DbValue, error) {
+		s, err := valueBoundToWit(start)
+		if err != nil {
+			return pg.DbValue{}, fmt.Errorf("range start: %w", err)
+		}
+		e, err := valueBoundToWit(end)
+		if err != nil {
+			return pg.DbValue{}, fmt.Errorf("range end: %w", err)
+		}
+		return pg.MakeDbValueRange(pg.Range{Name: name, Value: pg.ValuesRange{Start: s, End: e}}), nil
+	}}
+}
+
+// Decoded shapes for the recursive families.
+
+// Enum is the decoded form of an enumeration value.
+type Enum struct{ Name, Value string }
+
+// SparseVec is the decoded form of a sparse vector (and the input to [SparseVector]).
+type SparseVec struct {
+	Dim     int
+	Indices []int32
+	Values  []float32
+}
+
+// CompositeValue is the decoded form of a composite value.
+type CompositeValue struct {
+	Name   string
+	Fields []any
+}
+
+// DomainValue is the decoded form of a domain value.
+type DomainValue struct {
+	Name  string
+	Value any
+}
+
+// RangeValue is the decoded form of a user-defined range value.
+type RangeValue struct {
+	Name  string
+	Start Bound[any]
+	End   Bound[any]
+}
+
+// ── Parameter encoding ───────────────────────────────────────────────────────
+
+func encodeParam(v any) (pg.DbValue, error) {
+	switch x := v.(type) {
+	case nil:
+		return pg.MakeDbValueNull(), nil
+	case DbValue:
+		if x.encode != nil {
+			return x.encode()
+		}
+		return x.raw, nil
+	case bool:
+		return pg.MakeDbValueBoolean(x), nil
+	case int:
+		return pg.MakeDbValueInt8(int64(x)), nil
+	case int64:
+		return pg.MakeDbValueInt8(x), nil
+	case int32:
+		return pg.MakeDbValueInt4(x), nil
+	case int16:
+		return pg.MakeDbValueInt2(x), nil
+	case int8:
+		return pg.MakeDbValueInt2(int16(x)), nil
+	case float64:
+		return pg.MakeDbValueFloat8(x), nil
+	case float32:
+		return pg.MakeDbValueFloat4(x), nil
+	case string:
+		return pg.MakeDbValueText(x), nil
+	case []byte:
+		return pg.MakeDbValueBytea(x), nil
+	case uuid.UUID:
+		return pg.MakeDbValueUuid(uuidToWit(x)), nil
+	case time.Time:
+		return pg.MakeDbValueTimestamptz(goTimeToTimestamptz(x)), nil
+	default:
+		return pg.DbValue{}, fmt.Errorf("unsupported parameter type %T; wrap it with a postgres.* constructor", v)
+	}
+}
+
+func encodeParams(args []any) ([]pg.DbValue, error) {
+	if len(args) == 0 {
+		return nil, nil
+	}
+	out := make([]pg.DbValue, len(args))
+	for i, a := range args {
+		v, err := encodeParam(a)
+		if err != nil {
+			return nil, fmt.Errorf("golem/rdbms/postgres: parameter %d: %w", i+1, err)
+		}
+		out[i] = v
+	}
+	return out, nil
+}
+
+// ── Value decoding ────────────────────────────────────────────────────────────
+//
+// decode is split so the pure part (decodeFlat, every non-recursive family) is
+// natively testable, while the host-backed recursive part (decodeLazy, which
+// calls LazyDbValue.Get/Drop) stays reachable only from the query paths.
+
+func decode(v pg.DbValue) any {
+	if x, ok := decodeFlat(v); ok {
+		return x
+	}
+	return decodeLazy(v)
+}
+
+// decodeLazy handles the recursive families (array, composite, domain, custom
+// range). It calls the host to read each lazy child and drops it afterwards.
+func decodeLazy(v pg.DbValue) any {
+	switch v.Tag() {
+	case pg.DbValueArray:
+		lazies := v.Array()
+		out := make([]any, len(lazies))
+		for i, l := range lazies {
+			out[i] = decode(l.Get())
+			l.Drop()
+		}
+		return out
+	case pg.DbValueComposite:
+		c := v.Composite()
+		fields := make([]any, len(c.Values))
+		for i, l := range c.Values {
+			fields[i] = decode(l.Get())
+			l.Drop()
+		}
+		return CompositeValue{Name: c.Name, Fields: fields}
+	case pg.DbValueDomain:
+		d := v.Domain()
+		val := decode(d.Value.Get())
+		d.Value.Drop()
+		return DomainValue{Name: d.Name, Value: val}
+	case pg.DbValueRange:
+		rg := v.Range()
+		return RangeValue{Name: rg.Name, Start: valueBoundFromWit(rg.Value.Start), End: valueBoundFromWit(rg.Value.End)}
+	default:
+		// A newly appended WIT family we do not decode yet.
+		return fmt.Sprintf("unsupported(%s)", tagName(v.Tag()))
+	}
+}
+
+func valueBoundFromWit(b pg.ValueBound) Bound[any] {
+	switch b.Tag() {
+	case pg.ValueBoundIncluded:
+		l := b.Included()
+		val := decode(l.Get())
+		l.Drop()
+		return Included[any](val)
+	case pg.ValueBoundExcluded:
+		l := b.Excluded()
+		val := decode(l.Get())
+		l.Drop()
+		return Excluded[any](val)
+	default:
+		return Unbounded[any]()
+	}
+}
+
+// decodeFlat handles every non-recursive family; ok is false for the recursive
+// ones (array/composite/domain/range), which decodeLazy takes.
+func decodeFlat(v pg.DbValue) (any, bool) {
+	switch v.Tag() {
+	case pg.DbValueNull:
+		return nil, true
+	case pg.DbValueCharacter:
+		return v.Character(), true
+	case pg.DbValueInt2:
+		return v.Int2(), true
+	case pg.DbValueInt4:
+		return v.Int4(), true
+	case pg.DbValueInt8:
+		return v.Int8(), true
+	case pg.DbValueFloat4:
+		return v.Float4(), true
+	case pg.DbValueFloat8:
+		return v.Float8(), true
+	case pg.DbValueNumeric:
+		return v.Numeric(), true
+	case pg.DbValueBoolean:
+		return v.Boolean(), true
+	case pg.DbValueText:
+		return v.Text(), true
+	case pg.DbValueVarchar:
+		return v.Varchar(), true
+	case pg.DbValueBpchar:
+		return v.Bpchar(), true
+	case pg.DbValueTimestamp:
+		return timestampToGoTime(v.Timestamp(), time.UTC), true
+	case pg.DbValueTimestamptz:
+		return timestamptzToGoTime(v.Timestamptz()), true
+	case pg.DbValueDate:
+		return dateToGoTime(v.Date()), true
+	case pg.DbValueTime:
+		return witTimeToTypes(v.Time()), true
+	case pg.DbValueTimetz:
+		return types.Timetz{Time: witTimeToTypes(v.Timetz().Time), OffsetSeconds: int(v.Timetz().Offset)}, true
+	case pg.DbValueInterval:
+		iv := v.Interval()
+		return types.Interval{Months: int(iv.Months), Days: int(iv.Days), Microseconds: iv.Microseconds}, true
+	case pg.DbValueBytea:
+		return v.Bytea(), true
+	case pg.DbValueJson:
+		return v.Json(), true
+	case pg.DbValueJsonb:
+		return v.Jsonb(), true
+	case pg.DbValueJsonpath:
+		return v.Jsonpath(), true
+	case pg.DbValueXml:
+		return v.Xml(), true
+	case pg.DbValueUuid:
+		return uuidFromWit(v.Uuid()), true
+	case pg.DbValueInet:
+		return ipFromWit(v.Inet()), true
+	case pg.DbValueCidr:
+		return ipFromWit(v.Cidr()), true
+	case pg.DbValueMacaddr:
+		return macFromWit(v.Macaddr()), true
+	case pg.DbValueBit:
+		return v.Bit(), true
+	case pg.DbValueVarbit:
+		return v.Varbit(), true
+	case pg.DbValueMoney:
+		return v.Money(), true
+	case pg.DbValueOid:
+		return v.Oid(), true
+	case pg.DbValueVector:
+		return v.Vector(), true
+	case pg.DbValueHalfvec:
+		return v.Halfvec(), true
+	case pg.DbValueInt4range:
+		return int4RangeFromWit(v.Int4range()), true
+	case pg.DbValueInt8range:
+		return int8RangeFromWit(v.Int8range()), true
+	case pg.DbValueNumrange:
+		return numRangeFromWit(v.Numrange()), true
+	case pg.DbValueTsrange:
+		return tsRangeFromWit(v.Tsrange()), true
+	case pg.DbValueTstzrange:
+		return tstzRangeFromWit(v.Tstzrange()), true
+	case pg.DbValueDaterange:
+		return dateRangeFromWit(v.Daterange()), true
+	case pg.DbValueEnumeration:
+		e := v.Enumeration()
+		return Enum{Name: e.Name, Value: e.Value}, true
+	case pg.DbValueSparsevec:
+		s := v.Sparsevec()
+		return SparseVec{Dim: int(s.Dim), Indices: s.Indices, Values: s.Values}, true
+	default:
+		// array, composite, domain, range — recursive, handled by decodeLazy.
+		return nil, false
+	}
+}
+
+// ── UUID / temporal / net conversions ────────────────────────────────────────
+
+func uuidToWit(u uuid.UUID) pg.Uuid {
+	return pg.Uuid{
+		HighBits: binary.BigEndian.Uint64(u[0:8]),
+		LowBits:  binary.BigEndian.Uint64(u[8:16]),
+	}
+}
+
+func uuidFromWit(w pg.Uuid) uuid.UUID {
+	var u uuid.UUID
+	binary.BigEndian.PutUint64(u[0:8], w.HighBits)
+	binary.BigEndian.PutUint64(u[8:16], w.LowBits)
+	return u
+}
+
+func goTimeToTimestamp(t time.Time) pg.Timestamp {
+	return pg.Timestamp{
+		Date: pg.Date{Year: int32(t.Year()), Month: uint8(t.Month()), Day: uint8(t.Day())},
+		Time: pg.Time{Hour: uint8(t.Hour()), Minute: uint8(t.Minute()), Second: uint8(t.Second()), Nanosecond: uint32(t.Nanosecond())},
+	}
+}
+
+func goTimeToTimestamptz(t time.Time) pg.Timestamptz {
+	_, off := t.Zone()
+	return pg.Timestamptz{Timestamp: goTimeToTimestamp(t), Offset: int32(off)}
+}
+
+func timestampToGoTime(ts pg.Timestamp, loc *time.Location) time.Time {
+	return time.Date(int(ts.Date.Year), time.Month(ts.Date.Month), int(ts.Date.Day),
+		int(ts.Time.Hour), int(ts.Time.Minute), int(ts.Time.Second), int(ts.Time.Nanosecond), loc)
+}
+
+func timestamptzToGoTime(ts pg.Timestamptz) time.Time {
+	return timestampToGoTime(ts.Timestamp, time.FixedZone("", int(ts.Offset)))
+}
+
+func dateToGoTime(d pg.Date) time.Time {
+	return time.Date(int(d.Year), time.Month(d.Month), int(d.Day), 0, 0, 0, 0, time.UTC)
+}
+
+func witTimeToTypes(t pg.Time) types.Time {
+	return types.Time{Hour: int(t.Hour), Minute: int(t.Minute), Second: int(t.Second), Nanosecond: int(t.Nanosecond)}
+}
+
+func typesTimeToWit(t types.Time) pg.Time {
+	return pg.Time{Hour: uint8(t.Hour), Minute: uint8(t.Minute), Second: uint8(t.Second), Nanosecond: uint32(t.Nanosecond)}
+}
+
+func typesTimestampToWit(ts types.Timestamp) pg.Timestamp {
+	return pg.Timestamp{
+		Date: pg.Date{Year: int32(ts.Date.Year), Month: uint8(ts.Date.Month), Day: uint8(ts.Date.Day)},
+		Time: typesTimeToWit(ts.Time),
+	}
+}
+
+func ipToWit(a netip.Addr) rtypes.IpAddress {
+	if a.Is4() {
+		b := a.As4()
+		return rtypes.MakeIpAddressIpv4(witTypes.Tuple4[uint8, uint8, uint8, uint8]{F0: b[0], F1: b[1], F2: b[2], F3: b[3]})
+	}
+	b := a.As16()
+	g := func(i int) uint16 { return uint16(b[i])<<8 | uint16(b[i+1]) }
+	return rtypes.MakeIpAddressIpv6(witTypes.Tuple8[uint16, uint16, uint16, uint16, uint16, uint16, uint16, uint16]{
+		F0: g(0), F1: g(2), F2: g(4), F3: g(6), F4: g(8), F5: g(10), F6: g(12), F7: g(14),
+	})
+}
+
+func ipFromWit(a rtypes.IpAddress) netip.Addr {
+	if a.Tag() == rtypes.IpAddressIpv4 {
+		t := a.Ipv4()
+		return netip.AddrFrom4([4]byte{t.F0, t.F1, t.F2, t.F3})
+	}
+	t := a.Ipv6()
+	var b [16]byte
+	put := func(i int, v uint16) { b[i] = byte(v >> 8); b[i+1] = byte(v) }
+	put(0, t.F0)
+	put(2, t.F1)
+	put(4, t.F2)
+	put(6, t.F3)
+	put(8, t.F4)
+	put(10, t.F5)
+	put(12, t.F6)
+	put(14, t.F7)
+	return netip.AddrFrom16(b)
+}
+
+func macToWit(m types.MacAddr) rtypes.MacAddress {
+	return rtypes.MacAddress{Octets: witTypes.Tuple6[uint8, uint8, uint8, uint8, uint8, uint8]{
+		F0: m[0], F1: m[1], F2: m[2], F3: m[3], F4: m[4], F5: m[5],
+	}}
+}
+
+func macFromWit(m rtypes.MacAddress) types.MacAddr {
+	o := m.Octets
+	return types.MacAddr{o.F0, o.F1, o.F2, o.F3, o.F4, o.F5}
+}
+
+func goTimeToDate(t time.Time) pg.Date {
+	return pg.Date{Year: int32(t.Year()), Month: uint8(t.Month()), Day: uint8(t.Day())}
+}
+
+// ── Range bound conversions ───────────────────────────────────────────────────
+
+func int4BoundToWit(b Bound[int32]) pg.Int4bound {
+	switch b.Kind {
+	case BoundIncluded:
+		return pg.MakeInt4boundIncluded(b.Value)
+	case BoundExcluded:
+		return pg.MakeInt4boundExcluded(b.Value)
+	default:
+		return pg.MakeInt4boundUnbounded()
+	}
+}
+
+func int4BoundFromWit(b pg.Int4bound) Bound[int32] {
+	switch b.Tag() {
+	case pg.Int4boundIncluded:
+		return Included(b.Included())
+	case pg.Int4boundExcluded:
+		return Excluded(b.Excluded())
+	default:
+		return Unbounded[int32]()
+	}
+}
+
+func int4RangeFromWit(r pg.Int4range) Range[int32] {
+	return Range[int32]{Start: int4BoundFromWit(r.Start), End: int4BoundFromWit(r.End)}
+}
+
+func int8BoundToWit(b Bound[int64]) pg.Int8bound {
+	switch b.Kind {
+	case BoundIncluded:
+		return pg.MakeInt8boundIncluded(b.Value)
+	case BoundExcluded:
+		return pg.MakeInt8boundExcluded(b.Value)
+	default:
+		return pg.MakeInt8boundUnbounded()
+	}
+}
+
+func int8BoundFromWit(b pg.Int8bound) Bound[int64] {
+	switch b.Tag() {
+	case pg.Int8boundIncluded:
+		return Included(b.Included())
+	case pg.Int8boundExcluded:
+		return Excluded(b.Excluded())
+	default:
+		return Unbounded[int64]()
+	}
+}
+
+func int8RangeFromWit(r pg.Int8range) Range[int64] {
+	return Range[int64]{Start: int8BoundFromWit(r.Start), End: int8BoundFromWit(r.End)}
+}
+
+func numBoundToWit(b Bound[string]) pg.Numbound {
+	switch b.Kind {
+	case BoundIncluded:
+		return pg.MakeNumboundIncluded(b.Value)
+	case BoundExcluded:
+		return pg.MakeNumboundExcluded(b.Value)
+	default:
+		return pg.MakeNumboundUnbounded()
+	}
+}
+
+func numBoundFromWit(b pg.Numbound) Bound[string] {
+	switch b.Tag() {
+	case pg.NumboundIncluded:
+		return Included(b.Included())
+	case pg.NumboundExcluded:
+		return Excluded(b.Excluded())
+	default:
+		return Unbounded[string]()
+	}
+}
+
+func numRangeFromWit(r pg.Numrange) Range[string] {
+	return Range[string]{Start: numBoundFromWit(r.Start), End: numBoundFromWit(r.End)}
+}
+
+func tsBoundToWit(b Bound[time.Time]) pg.Tsbound {
+	switch b.Kind {
+	case BoundIncluded:
+		return pg.MakeTsboundIncluded(goTimeToTimestamp(b.Value))
+	case BoundExcluded:
+		return pg.MakeTsboundExcluded(goTimeToTimestamp(b.Value))
+	default:
+		return pg.MakeTsboundUnbounded()
+	}
+}
+
+func tsBoundFromWit(b pg.Tsbound) Bound[time.Time] {
+	switch b.Tag() {
+	case pg.TsboundIncluded:
+		return Included(timestampToGoTime(b.Included(), time.UTC))
+	case pg.TsboundExcluded:
+		return Excluded(timestampToGoTime(b.Excluded(), time.UTC))
+	default:
+		return Unbounded[time.Time]()
+	}
+}
+
+func tsRangeFromWit(r pg.Tsrange) Range[time.Time] {
+	return Range[time.Time]{Start: tsBoundFromWit(r.Start), End: tsBoundFromWit(r.End)}
+}
+
+func tstzBoundToWit(b Bound[time.Time]) pg.Tstzbound {
+	switch b.Kind {
+	case BoundIncluded:
+		return pg.MakeTstzboundIncluded(goTimeToTimestamptz(b.Value))
+	case BoundExcluded:
+		return pg.MakeTstzboundExcluded(goTimeToTimestamptz(b.Value))
+	default:
+		return pg.MakeTstzboundUnbounded()
+	}
+}
+
+func tstzBoundFromWit(b pg.Tstzbound) Bound[time.Time] {
+	switch b.Tag() {
+	case pg.TstzboundIncluded:
+		return Included(timestamptzToGoTime(b.Included()))
+	case pg.TstzboundExcluded:
+		return Excluded(timestamptzToGoTime(b.Excluded()))
+	default:
+		return Unbounded[time.Time]()
+	}
+}
+
+func tstzRangeFromWit(r pg.Tstzrange) Range[time.Time] {
+	return Range[time.Time]{Start: tstzBoundFromWit(r.Start), End: tstzBoundFromWit(r.End)}
+}
+
+func dateBoundToWit(b Bound[time.Time]) pg.Datebound {
+	switch b.Kind {
+	case BoundIncluded:
+		return pg.MakeDateboundIncluded(goTimeToDate(b.Value))
+	case BoundExcluded:
+		return pg.MakeDateboundExcluded(goTimeToDate(b.Value))
+	default:
+		return pg.MakeDateboundUnbounded()
+	}
+}
+
+func dateBoundFromWit(b pg.Datebound) Bound[time.Time] {
+	switch b.Tag() {
+	case pg.DateboundIncluded:
+		return Included(dateToGoTime(b.Included()))
+	case pg.DateboundExcluded:
+		return Excluded(dateToGoTime(b.Excluded()))
+	default:
+		return Unbounded[time.Time]()
+	}
+}
+
+func dateRangeFromWit(r pg.Daterange) Range[time.Time] {
+	return Range[time.Time]{Start: dateBoundFromWit(r.Start), End: dateBoundFromWit(r.End)}
+}
+
+// valueBoundToWit builds a host value-bound for a custom range, wrapping the
+// bound value in a lazy resource (a host call).
+func valueBoundToWit(b Bound[any]) (pg.ValueBound, error) {
+	switch b.Kind {
+	case BoundIncluded:
+		v, err := encodeParam(b.Value)
+		if err != nil {
+			return pg.ValueBound{}, err
+		}
+		return pg.MakeValueBoundIncluded(pg.MakeLazyDbValue(v)), nil
+	case BoundExcluded:
+		v, err := encodeParam(b.Value)
+		if err != nil {
+			return pg.ValueBound{}, err
+		}
+		return pg.MakeValueBoundExcluded(pg.MakeLazyDbValue(v)), nil
+	default:
+		return pg.MakeValueBoundUnbounded(), nil
+	}
+}
+
+// ── Rows / columns / result sets ─────────────────────────────────────────────
+
+// Column describes a result column.
+type Column struct {
+	Ordinal    uint64
+	Name       string
+	DbTypeName string
+}
+
+func convColumns(cols []pg.DbColumn) []Column {
+	out := make([]Column, len(cols))
+	for i, c := range cols {
+		out[i] = Column{Ordinal: c.Ordinal, Name: c.Name, DbTypeName: c.DbTypeName}
+	}
+	return out
+}
+
+// Row is a single result row, read positionally.
+type Row struct{ values []pg.DbValue }
+
+// Len returns the number of columns in the row.
+func (r Row) Len() int { return len(r.values) }
+
+func (r Row) at(i int) (pg.DbValue, error) {
+	if i < 0 || i >= len(r.values) {
+		return pg.DbValue{}, fmt.Errorf("golem/rdbms/postgres: column index %d out of range (%d columns)", i, len(r.values))
+	}
+	return r.values[i], nil
+}
+
+func typeErr(i int, v pg.DbValue, want string) error {
+	return fmt.Errorf("golem/rdbms/postgres: column %d is %s, not %s", i, tagName(v.Tag()), want)
+}
+
+// IsNull reports whether column i is SQL NULL.
+func (r Row) IsNull(i int) bool {
+	v, err := r.at(i)
+	return err == nil && v.Tag() == pg.DbValueNull
+}
+
+// Get decodes column i to a Go value: the int/float widths, string, bool,
+// []byte, [uuid.UUID], [time.Time] and the [types] structs for the families
+// that map cleanly, nil for NULL, or an opaque [DbValue] for the composite
+// families not yet decoded.
+func (r Row) Get(i int) (any, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return nil, err
+	}
+	return decode(v), nil
+}
+
+// Int64 reads an integer column (any integer width, money or oid) as int64.
+func (r Row) Int64(i int) (int64, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return 0, err
+	}
+	switch v.Tag() {
+	case pg.DbValueInt8:
+		return v.Int8(), nil
+	case pg.DbValueInt4:
+		return int64(v.Int4()), nil
+	case pg.DbValueInt2:
+		return int64(v.Int2()), nil
+	case pg.DbValueCharacter:
+		return int64(v.Character()), nil
+	case pg.DbValueMoney:
+		return v.Money(), nil
+	case pg.DbValueOid:
+		return int64(v.Oid()), nil
+	default:
+		return 0, typeErr(i, v, "int64")
+	}
+}
+
+// Float64 reads a floating-point column as float64.
+func (r Row) Float64(i int) (float64, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return 0, err
+	}
+	switch v.Tag() {
+	case pg.DbValueFloat8:
+		return v.Float8(), nil
+	case pg.DbValueFloat4:
+		return float64(v.Float4()), nil
+	default:
+		return 0, typeErr(i, v, "float64")
+	}
+}
+
+// String reads a textual column (text/varchar/bpchar, numeric, json family or
+// xml) as a string.
+func (r Row) String(i int) (string, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return "", err
+	}
+	switch v.Tag() {
+	case pg.DbValueText:
+		return v.Text(), nil
+	case pg.DbValueVarchar:
+		return v.Varchar(), nil
+	case pg.DbValueBpchar:
+		return v.Bpchar(), nil
+	case pg.DbValueNumeric:
+		return v.Numeric(), nil
+	case pg.DbValueJson:
+		return v.Json(), nil
+	case pg.DbValueJsonb:
+		return v.Jsonb(), nil
+	case pg.DbValueJsonpath:
+		return v.Jsonpath(), nil
+	case pg.DbValueXml:
+		return v.Xml(), nil
+	default:
+		return "", typeErr(i, v, "string")
+	}
+}
+
+// Bool reads a boolean column.
+func (r Row) Bool(i int) (bool, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return false, err
+	}
+	if v.Tag() != pg.DbValueBoolean {
+		return false, typeErr(i, v, "bool")
+	}
+	return v.Boolean(), nil
+}
+
+// Bytes reads a bytea column.
+func (r Row) Bytes(i int) ([]byte, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return nil, err
+	}
+	if v.Tag() != pg.DbValueBytea {
+		return nil, typeErr(i, v, "bytea")
+	}
+	return v.Bytea(), nil
+}
+
+// UUID reads a uuid column.
+func (r Row) UUID(i int) (uuid.UUID, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return uuid.UUID{}, err
+	}
+	if v.Tag() != pg.DbValueUuid {
+		return uuid.UUID{}, typeErr(i, v, "uuid")
+	}
+	return uuidFromWit(v.Uuid()), nil
+}
+
+// Time reads a timestamp, timestamptz or date column as a [time.Time]
+// (timestamps without a zone and dates are returned in UTC).
+func (r Row) Time(i int) (time.Time, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return time.Time{}, err
+	}
+	switch v.Tag() {
+	case pg.DbValueTimestamp:
+		return timestampToGoTime(v.Timestamp(), time.UTC), nil
+	case pg.DbValueTimestamptz:
+		return timestamptzToGoTime(v.Timestamptz()), nil
+	case pg.DbValueDate:
+		return dateToGoTime(v.Date()), nil
+	default:
+		return time.Time{}, typeErr(i, v, "time.Time")
+	}
+}
+
+// Typed getters for the exotic families. The flat ones (ranges, enum, sparse
+// vector) read directly; the recursive ones (array, composite, domain, custom
+// range) go through the host lazy resources, so — like [Row.Get] — they only run
+// inside a query, not native tests.
+
+// Int4Range reads an int4range column.
+func (r Row) Int4Range(i int) (Range[int32], error) {
+	v, err := r.at(i)
+	if err != nil {
+		return Range[int32]{}, err
+	}
+	if v.Tag() != pg.DbValueInt4range {
+		return Range[int32]{}, typeErr(i, v, "int4range")
+	}
+	return int4RangeFromWit(v.Int4range()), nil
+}
+
+// Int8Range reads an int8range column.
+func (r Row) Int8Range(i int) (Range[int64], error) {
+	v, err := r.at(i)
+	if err != nil {
+		return Range[int64]{}, err
+	}
+	if v.Tag() != pg.DbValueInt8range {
+		return Range[int64]{}, typeErr(i, v, "int8range")
+	}
+	return int8RangeFromWit(v.Int8range()), nil
+}
+
+// NumRange reads a numrange column (bounds as numeric strings).
+func (r Row) NumRange(i int) (Range[string], error) {
+	v, err := r.at(i)
+	if err != nil {
+		return Range[string]{}, err
+	}
+	if v.Tag() != pg.DbValueNumrange {
+		return Range[string]{}, typeErr(i, v, "numrange")
+	}
+	return numRangeFromWit(v.Numrange()), nil
+}
+
+// TsRange reads a tsrange column (bounds in UTC).
+func (r Row) TsRange(i int) (Range[time.Time], error) {
+	v, err := r.at(i)
+	if err != nil {
+		return Range[time.Time]{}, err
+	}
+	if v.Tag() != pg.DbValueTsrange {
+		return Range[time.Time]{}, typeErr(i, v, "tsrange")
+	}
+	return tsRangeFromWit(v.Tsrange()), nil
+}
+
+// TstzRange reads a tstzrange column (bound offsets preserved).
+func (r Row) TstzRange(i int) (Range[time.Time], error) {
+	v, err := r.at(i)
+	if err != nil {
+		return Range[time.Time]{}, err
+	}
+	if v.Tag() != pg.DbValueTstzrange {
+		return Range[time.Time]{}, typeErr(i, v, "tstzrange")
+	}
+	return tstzRangeFromWit(v.Tstzrange()), nil
+}
+
+// DateRange reads a daterange column (bounds in UTC, date only).
+func (r Row) DateRange(i int) (Range[time.Time], error) {
+	v, err := r.at(i)
+	if err != nil {
+		return Range[time.Time]{}, err
+	}
+	if v.Tag() != pg.DbValueDaterange {
+		return Range[time.Time]{}, typeErr(i, v, "daterange")
+	}
+	return dateRangeFromWit(v.Daterange()), nil
+}
+
+// Enum reads an enumeration column.
+func (r Row) Enum(i int) (Enum, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return Enum{}, err
+	}
+	if v.Tag() != pg.DbValueEnumeration {
+		return Enum{}, typeErr(i, v, "enumeration")
+	}
+	e := v.Enumeration()
+	return Enum{Name: e.Name, Value: e.Value}, nil
+}
+
+// SparseVec reads a sparsevec column.
+func (r Row) SparseVec(i int) (SparseVec, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return SparseVec{}, err
+	}
+	if v.Tag() != pg.DbValueSparsevec {
+		return SparseVec{}, typeErr(i, v, "sparsevec")
+	}
+	s := v.Sparsevec()
+	return SparseVec{Dim: int(s.Dim), Indices: s.Indices, Values: s.Values}, nil
+}
+
+// Array reads an array column into a slice, each element decoded like [Row.Get].
+func (r Row) Array(i int) ([]any, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return nil, err
+	}
+	if v.Tag() != pg.DbValueArray {
+		return nil, typeErr(i, v, "array")
+	}
+	return decodeLazy(v).([]any), nil
+}
+
+// Composite reads a composite column.
+func (r Row) Composite(i int) (CompositeValue, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return CompositeValue{}, err
+	}
+	if v.Tag() != pg.DbValueComposite {
+		return CompositeValue{}, typeErr(i, v, "composite")
+	}
+	return decodeLazy(v).(CompositeValue), nil
+}
+
+// Domain reads a domain column.
+func (r Row) Domain(i int) (DomainValue, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return DomainValue{}, err
+	}
+	if v.Tag() != pg.DbValueDomain {
+		return DomainValue{}, typeErr(i, v, "domain")
+	}
+	return decodeLazy(v).(DomainValue), nil
+}
+
+// Range reads a user-defined range column (use the typed range getters for the
+// built-in range types).
+func (r Row) Range(i int) (RangeValue, error) {
+	v, err := r.at(i)
+	if err != nil {
+		return RangeValue{}, err
+	}
+	if v.Tag() != pg.DbValueRange {
+		return RangeValue{}, typeErr(i, v, "range")
+	}
+	return decodeLazy(v).(RangeValue), nil
+}
+
+// Scan decodes the row into the given pointers, one per column. Supported
+// destinations are *int64, *int, *float64, *string, *bool, *[]byte,
+// *uuid.UUID, *time.Time and *any (which receives whatever [Row.Get] returns).
+func (r Row) Scan(dest ...any) error {
+	if len(dest) != len(r.values) {
+		return fmt.Errorf("golem/rdbms/postgres: Scan: %d destination(s) for %d column(s)", len(dest), len(r.values))
+	}
+	for i, d := range dest {
+		if err := r.scanOne(i, d); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (r Row) scanOne(i int, d any) error {
+	switch p := d.(type) {
+	case *any:
+		v, err := r.Get(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	case *int64:
+		v, err := r.Int64(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	case *int:
+		v, err := r.Int64(i)
+		if err != nil {
+			return err
+		}
+		*p = int(v)
+	case *float64:
+		v, err := r.Float64(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	case *string:
+		v, err := r.String(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	case *bool:
+		v, err := r.Bool(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	case *[]byte:
+		v, err := r.Bytes(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	case *uuid.UUID:
+		v, err := r.UUID(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	case *time.Time:
+		v, err := r.Time(i)
+		if err != nil {
+			return err
+		}
+		*p = v
+	default:
+		return fmt.Errorf("golem/rdbms/postgres: Scan: unsupported destination type %T for column %d", d, i)
+	}
+	return nil
+}
+
+// ResultSet is the eager result of a [DB.Query] / [Tx.Query]: all columns and
+// rows, already fetched.
+type ResultSet struct {
+	columns []Column
+	rows    []Row
+}
+
+func newResultSet(res pg.DbResult) *ResultSet {
+	rows := make([]Row, len(res.Rows))
+	for i, r := range res.Rows {
+		rows[i] = Row{values: r.Values}
+	}
+	return &ResultSet{columns: convColumns(res.Columns), rows: rows}
+}
+
+// Columns returns the result column metadata.
+func (rs *ResultSet) Columns() []Column { return rs.columns }
+
+// Rows returns the result rows.
+func (rs *ResultSet) Rows() []Row { return rs.rows }
+
+// ── Streaming results ─────────────────────────────────────────────────────────
+
+// Stream is a cursor over a [DB.QueryStream] / [Tx.QueryStream] result. Iterate
+// with [Stream.Next] until it reports no more rows, then call [Stream.Close].
+type Stream struct {
+	raw  *pg.DbResultStream
+	cols []Column
+	buf  []Row
+	idx  int
+	done bool
+}
+
+// Columns returns the result column metadata.
+func (s *Stream) Columns() []Column {
+	if s.cols == nil {
+		s.cols = convColumns(s.raw.GetColumns())
+	}
+	return s.cols
+}
+
+// Next returns the next row. ok is false (with a nil error) once the stream is
+// exhausted.
+func (s *Stream) Next() (row Row, ok bool, err error) {
+	for s.idx >= len(s.buf) {
+		if s.done {
+			return Row{}, false, nil
+		}
+		opt := s.raw.GetNext()
+		if opt.IsNone() {
+			s.done = true
+			return Row{}, false, nil
+		}
+		batch := opt.Some()
+		s.buf = make([]Row, len(batch))
+		for i, r := range batch {
+			s.buf[i] = Row{values: r.Values}
+		}
+		s.idx = 0
+	}
+	row = s.buf[s.idx]
+	s.idx++
+	return row, true, nil
+}
+
+// Close releases the stream.
+func (s *Stream) Close() { s.raw.Drop() }
+
+// ── Connection ────────────────────────────────────────────────────────────────
+
+// DB is an open Postgres connection.
+type DB struct{ raw *pg.DbConnection }
+
+// Open opens a connection to the given Postgres URL
+// ("postgres://user:pass@host:port/database").
+func Open(address string) (*DB, error) {
+	r := pg.DbConnectionOpen(address)
+	if r.IsErr() {
+		return nil, pgError(r.Err())
+	}
+	return &DB{raw: r.Ok()}, nil
+}
+
+// Query runs a statement that returns rows.
+func (db *DB) Query(sql string, args ...any) (*ResultSet, error) {
+	params, err := encodeParams(args)
+	if err != nil {
+		return nil, err
+	}
+	r := db.raw.Query(sql, params)
+	if r.IsErr() {
+		return nil, pgError(r.Err())
+	}
+	return newResultSet(r.Ok()), nil
+}
+
+// Exec runs a statement that does not return rows, returning the number of
+// affected rows.
+func (db *DB) Exec(sql string, args ...any) (uint64, error) {
+	params, err := encodeParams(args)
+	if err != nil {
+		return 0, err
+	}
+	r := db.raw.Execute(sql, params)
+	if r.IsErr() {
+		return 0, pgError(r.Err())
+	}
+	return r.Ok(), nil
+}
+
+// QueryStream runs a row-returning statement and streams the results.
+func (db *DB) QueryStream(sql string, args ...any) (*Stream, error) {
+	params, err := encodeParams(args)
+	if err != nil {
+		return nil, err
+	}
+	r := db.raw.QueryStream(sql, params)
+	if r.IsErr() {
+		return nil, pgError(r.Err())
+	}
+	return &Stream{raw: r.Ok()}, nil
+}
+
+// Begin starts a transaction.
+func (db *DB) Begin() (*Tx, error) {
+	r := db.raw.BeginTransaction()
+	if r.IsErr() {
+		return nil, pgError(r.Err())
+	}
+	return &Tx{raw: r.Ok()}, nil
+}
+
+// Transaction runs fn inside a transaction, committing if fn returns nil and
+// rolling back (and returning fn's error) otherwise.
+func (db *DB) Transaction(fn func(*Tx) error) error {
+	tx, err := db.Begin()
+	if err != nil {
+		return err
+	}
+	if err := fn(tx); err != nil {
+		_ = tx.Rollback()
+		return err
+	}
+	return tx.Commit()
+}
+
+// Close releases the connection.
+func (db *DB) Close() { db.raw.Drop() }
+
+// ── Transactions ──────────────────────────────────────────────────────────────
+
+// Tx is an in-progress transaction. Finish it with [Tx.Commit] or [Tx.Rollback].
+type Tx struct{ raw *pg.DbTransaction }
+
+// Query runs a row-returning statement in the transaction.
+func (tx *Tx) Query(sql string, args ...any) (*ResultSet, error) {
+	params, err := encodeParams(args)
+	if err != nil {
+		return nil, err
+	}
+	r := tx.raw.Query(sql, params)
+	if r.IsErr() {
+		return nil, pgError(r.Err())
+	}
+	return newResultSet(r.Ok()), nil
+}
+
+// Exec runs a non-row-returning statement in the transaction, returning the
+// number of affected rows.
+func (tx *Tx) Exec(sql string, args ...any) (uint64, error) {
+	params, err := encodeParams(args)
+	if err != nil {
+		return 0, err
+	}
+	r := tx.raw.Execute(sql, params)
+	if r.IsErr() {
+		return 0, pgError(r.Err())
+	}
+	return r.Ok(), nil
+}
+
+// QueryStream runs a row-returning statement in the transaction and streams the
+// results.
+func (tx *Tx) QueryStream(sql string, args ...any) (*Stream, error) {
+	params, err := encodeParams(args)
+	if err != nil {
+		return nil, err
+	}
+	r := tx.raw.QueryStream(sql, params)
+	if r.IsErr() {
+		return nil, pgError(r.Err())
+	}
+	return &Stream{raw: r.Ok()}, nil
+}
+
+// Commit commits the transaction.
+func (tx *Tx) Commit() error {
+	r := tx.raw.Commit()
+	tx.raw.Drop()
+	if r.IsErr() {
+		return pgError(r.Err())
+	}
+	return nil
+}
+
+// Rollback aborts the transaction.
+func (tx *Tx) Rollback() error {
+	r := tx.raw.Rollback()
+	tx.raw.Drop()
+	if r.IsErr() {
+		return pgError(r.Err())
+	}
+	return nil
+}
diff --git a/sdks/go/golem/rdbms/postgres/postgres_test.go b/sdks/go/golem/rdbms/postgres/postgres_test.go
new file mode 100644
index 0000000000..c83ca31c6d
--- /dev/null
+++ b/sdks/go/golem/rdbms/postgres/postgres_test.go
@@ -0,0 +1,330 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 postgres
+
+import (
+	"net/netip"
+	"testing"
+	"time"
+
+	"github.com/golemcloud/golem/sdks/go/golem"
+	pg "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_rdbms_postgres"
+	"github.com/golemcloud/golem/sdks/go/golem/rdbms/types"
+)
+
+// TestEncodeParamTags — each Go value coerces to the expected db-value family.
+func TestEncodeParamTags(t *testing.T) {
+	cases := []struct {
+		in   any
+		want uint8
+	}{
+		{nil, pg.DbValueNull},
+		{true, pg.DbValueBoolean},
+		{int(1), pg.DbValueInt8},
+		{int64(1), pg.DbValueInt8},
+		{int32(1), pg.DbValueInt4},
+		{int16(1), pg.DbValueInt2},
+		{int8(1), pg.DbValueInt2},
+		{float64(1), pg.DbValueFloat8},
+		{float32(1), pg.DbValueFloat4},
+		{"s", pg.DbValueText},
+		{[]byte{1}, pg.DbValueBytea},
+		{golem.UUID{}, pg.DbValueUuid},
+		{time.Now().UTC(), pg.DbValueTimestamptz},
+		{Numeric("1.5"), pg.DbValueNumeric},
+		{JSONB(`{}`), pg.DbValueJsonb},
+		{Int4(3), pg.DbValueInt4},
+	}
+	for _, c := range cases {
+		v, err := encodeParam(c.in)
+		if err != nil {
+			t.Fatalf("encodeParam(%T) error: %v", c.in, err)
+		}
+		if v.Tag() != c.want {
+			t.Fatalf("encodeParam(%T) tag = %s, want %s", c.in, tagName(v.Tag()), tagName(c.want))
+		}
+	}
+}
+
+// TestEncodeParamUnsupported — an unhandled type is a clear error, not a panic.
+func TestEncodeParamUnsupported(t *testing.T) {
+	if _, err := encodeParam(struct{ X int }{}); err == nil {
+		t.Fatal("expected error for unsupported type")
+	}
+	if _, err := encodeParam(uint64(1)); err == nil {
+		t.Fatal("expected error for uint64 (use a constructor)")
+	}
+}
+
+// TestTypedGetters — typed getters read the matching families and reject others.
+func TestTypedGetters(t *testing.T) {
+	r := Row{values: []pg.DbValue{
+		pg.MakeDbValueInt8(42),
+		pg.MakeDbValueFloat8(3.5),
+		pg.MakeDbValueText("hello"),
+		pg.MakeDbValueBoolean(true),
+		pg.MakeDbValueBytea([]byte{1, 2, 3}),
+		pg.MakeDbValueNull(),
+	}}
+
+	if got, err := r.Int64(0); err != nil || got != 42 {
+		t.Fatalf("Int64 = %d, %v", got, err)
+	}
+	if got, err := r.Float64(1); err != nil || got != 3.5 {
+		t.Fatalf("Float64 = %v, %v", got, err)
+	}
+	if got, err := r.String(2); err != nil || got != "hello" {
+		t.Fatalf("String = %q, %v", got, err)
+	}
+	if got, err := r.Bool(3); err != nil || !got {
+		t.Fatalf("Bool = %v, %v", got, err)
+	}
+	if got, err := r.Bytes(4); err != nil || len(got) != 3 || got[2] != 3 {
+		t.Fatalf("Bytes = %v, %v", got, err)
+	}
+	if !r.IsNull(5) {
+		t.Fatal("column 5 should be null")
+	}
+	if r.IsNull(0) {
+		t.Fatal("column 0 should not be null")
+	}
+
+	// Mismatch is an error, not a panic.
+	if _, err := r.Int64(2); err == nil {
+		t.Fatal("Int64 on text should error")
+	}
+	// Out of range.
+	if _, err := r.Int64(99); err == nil {
+		t.Fatal("Int64 out of range should error")
+	}
+}
+
+// TestInt64Widths — every integer family reads through Int64.
+func TestInt64Widths(t *testing.T) {
+	r := Row{values: []pg.DbValue{
+		pg.MakeDbValueInt2(2),
+		pg.MakeDbValueInt4(4),
+		pg.MakeDbValueInt8(8),
+		pg.MakeDbValueCharacter(1),
+		pg.MakeDbValueMoney(100),
+		pg.MakeDbValueOid(7),
+	}}
+	want := []int64{2, 4, 8, 1, 100, 7}
+	for i, w := range want {
+		if got, err := r.Int64(i); err != nil || got != w {
+			t.Fatalf("Int64(%d) = %d, %v; want %d", i, got, err, w)
+		}
+	}
+}
+
+// Row.Scan and Row.Get route through the recursive decoder (host-backed), so they
+// are exercised end-to-end in the playground demo rather than here; the typed
+// getters they dispatch to are covered directly above.
+
+// mustFlat decodes a flat value, failing if it is not a flat family.
+func mustFlat(t *testing.T, v pg.DbValue) any {
+	t.Helper()
+	x, ok := decodeFlat(v)
+	if !ok {
+		t.Fatalf("%s should be a flat family", tagName(v.Tag()))
+	}
+	return x
+}
+
+// TestDecodeFlat — the pure decoder maps each flat family to the expected Go type.
+func TestDecodeFlat(t *testing.T) {
+	if v := mustFlat(t, pg.MakeDbValueNull()); v != nil {
+		t.Fatalf("null = %v", v)
+	}
+	if v := mustFlat(t, pg.MakeDbValueInt4(5)); v.(int32) != 5 {
+		t.Fatalf("int4 = %v", v)
+	}
+	if v := mustFlat(t, pg.MakeDbValueNumeric("1.25")); v.(string) != "1.25" {
+		t.Fatalf("numeric = %v", v)
+	}
+	if v := mustFlat(t, pg.MakeDbValueJsonb(`{"a":1}`)); v.(string) != `{"a":1}` {
+		t.Fatalf("jsonb = %v", v)
+	}
+	if v := mustFlat(t, pg.MakeDbValueVector([]float32{1, 2})); len(v.([]float32)) != 2 {
+		t.Fatalf("vector = %v", v)
+	}
+
+	// Enumeration and sparsevec decode to their typed structs.
+	e := mustFlat(t, pg.MakeDbValueEnumeration(pg.Enumeration{Name: "color", Value: "red"})).(Enum)
+	if e.Name != "color" || e.Value != "red" {
+		t.Fatalf("enum = %+v", e)
+	}
+	sv := mustFlat(t, pg.MakeDbValueSparsevec(pg.SparseVec{Dim: 5, Indices: []int32{1, 3}, Values: []float32{9, 8}})).(SparseVec)
+	if sv.Dim != 5 || len(sv.Indices) != 2 || sv.Values[1] != 8 {
+		t.Fatalf("sparsevec = %+v", sv)
+	}
+
+	// The recursive families are NOT flat.
+	if _, ok := decodeFlat(pg.MakeDbValueArray(nil)); ok {
+		t.Fatal("array should not be a flat family")
+	}
+}
+
+// TestFlatRanges — the built-in ranges round-trip through their constructors and
+// the pure decoder, exercising the generic Bound/Range helpers.
+func TestFlatRanges(t *testing.T) {
+	i4 := Int4Range(Range[int32]{Start: Included(int32(1)), End: Excluded(int32(10))})
+	if got := mustFlat(t, i4.raw).(Range[int32]); got.Start != Included(int32(1)) || got.End != Excluded(int32(10)) {
+		t.Fatalf("int4range = %+v", got)
+	}
+
+	num := NumRange(Range[string]{Start: Included("1.5"), End: Unbounded[string]()})
+	got := mustFlat(t, num.raw).(Range[string])
+	if got.Start != Included("1.5") || got.End.Kind != BoundUnbounded {
+		t.Fatalf("numrange = %+v", got)
+	}
+
+	day := time.Date(2026, 7, 30, 0, 0, 0, 0, time.UTC)
+	dr := DateRange(Range[time.Time]{Start: Included(day), End: Excluded(day.AddDate(0, 0, 7))})
+	drGot := mustFlat(t, dr.raw).(Range[time.Time])
+	if !drGot.Start.Value.Equal(day) || drGot.End.Kind != BoundExcluded {
+		t.Fatalf("daterange = %+v", drGot)
+	}
+}
+
+// TestTagName — display names key on the generated constants, with a diagnosable
+// fallback for an unrecognized (e.g. newly appended) tag.
+func TestTagName(t *testing.T) {
+	cases := []struct {
+		tag  uint8
+		want string
+	}{
+		{pg.DbValueCharacter, "character"},
+		{pg.DbValueNumeric, "numeric"},
+		{pg.DbValueUuid, "uuid"},
+		{pg.DbValueSparsevec, "sparsevec"},
+		{200, "unknown(200)"},
+	}
+	for _, c := range cases {
+		if got := tagName(c.tag); got != c.want {
+			t.Fatalf("tagName(%d) = %q, want %q", c.tag, got, c.want)
+		}
+	}
+}
+
+// TestTimeRoundTrip — time.Time survives the timestamptz encode/decode.
+func TestTimeRoundTrip(t *testing.T) {
+	orig := time.Date(2026, 7, 30, 12, 34, 56, 123456000, time.FixedZone("", 2*3600))
+	got := timestamptzToGoTime(goTimeToTimestamptz(orig))
+	if !got.Equal(orig) {
+		t.Fatalf("timestamptz round-trip = %v, want %v", got, orig)
+	}
+	if _, off := got.Zone(); off != 2*3600 {
+		t.Fatalf("offset = %d, want %d", off, 2*3600)
+	}
+
+	// A date decodes to midnight UTC.
+	d := dateToGoTime(pg.Date{Year: 2026, Month: 7, Day: 30})
+	if d.Year() != 2026 || d.Month() != 7 || d.Day() != 30 || d.Hour() != 0 {
+		t.Fatalf("date = %v", d)
+	}
+}
+
+// TestExoticGetters — the typed getters for the flat exotic families read the
+// matching column and reject others. (The recursive getters — Array/Composite/
+// Domain/Range — are host-backed and exercised in the playground demo.)
+func TestExoticGetters(t *testing.T) {
+	r := Row{values: []pg.DbValue{
+		Int4Range(Range[int32]{Start: Included(int32(1)), End: Excluded(int32(10))}).raw,
+		Enumeration("mood", "happy").raw,
+		pg.MakeDbValueSparsevec(pg.SparseVec{Dim: 3, Indices: []int32{0, 2}, Values: []float32{1, 2}}),
+		pg.MakeDbValueText("nope"),
+	}}
+
+	if got, err := r.Int4Range(0); err != nil || got.Start != Included(int32(1)) || got.End != Excluded(int32(10)) {
+		t.Fatalf("Int4Range = %+v, %v", got, err)
+	}
+	if got, err := r.Enum(1); err != nil || got.Name != "mood" || got.Value != "happy" {
+		t.Fatalf("Enum = %+v, %v", got, err)
+	}
+	if got, err := r.SparseVec(2); err != nil || got.Dim != 3 || len(got.Indices) != 2 || got.Values[1] != 2 {
+		t.Fatalf("SparseVec = %+v, %v", got, err)
+	}
+
+	// Type mismatches are errors, not panics.
+	if _, err := r.Int4Range(3); err == nil {
+		t.Fatal("Int4Range on text should error")
+	}
+	if _, err := r.Enum(0); err == nil {
+		t.Fatal("Enum on int4range should error")
+	}
+	if _, err := r.SparseVec(3); err == nil {
+		t.Fatal("SparseVec on text should error")
+	}
+}
+
+// TestTemporalTypes — time/timetz/interval decode into the types structs.
+func TestTemporalTypes(t *testing.T) {
+	tm := mustFlat(t, pg.MakeDbValueTime(pg.Time{Hour: 1, Minute: 2, Second: 3, Nanosecond: 4})).(types.Time)
+	if tm.Hour != 1 || tm.Minute != 2 || tm.Second != 3 || tm.Nanosecond != 4 {
+		t.Fatalf("time = %+v", tm)
+	}
+	iv := mustFlat(t, pg.MakeDbValueInterval(pg.Interval{Months: 1, Days: 2, Microseconds: 3})).(types.Interval)
+	if iv.Months != 1 || iv.Days != 2 || iv.Microseconds != 3 {
+		t.Fatalf("interval = %+v", iv)
+	}
+}
+
+// TestUUIDRoundTrip — the big/low-bits split is order-preserving.
+func TestUUIDRoundTrip(t *testing.T) {
+	var u golem.UUID
+	for i := range u {
+		u[i] = byte(i + 1)
+	}
+	if got := uuidFromWit(uuidToWit(u)); got != u {
+		t.Fatalf("uuid round-trip = %v, want %v", got, u)
+	}
+}
+
+// TestNetRoundTrip — inet (v4 and v6) and macaddr survive conversion.
+func TestNetRoundTrip(t *testing.T) {
+	for _, s := range []string{"192.168.1.5", "2001:db8::1"} {
+		a := netip.MustParseAddr(s)
+		got := ipFromWit(ipToWit(a))
+		if got != a {
+			t.Fatalf("ip round-trip %q = %v", s, got)
+		}
+	}
+	m := types.MacAddr{0xde, 0xad, 0xbe, 0xef, 0x00, 0x01}
+	if got := macFromWit(macToWit(m)); got != m {
+		t.Fatalf("mac round-trip = %v", got)
+	}
+}
+
+// TestErrorMapping — each host error variant maps to the right kind/message.
+func TestErrorMapping(t *testing.T) {
+	cases := []struct {
+		raw  pg.Error
+		kind ErrorKind
+		msg  string
+	}{
+		{pg.MakeErrorConnectionFailure("c"), ConnectionFailure, "c"},
+		{pg.MakeErrorQueryParameterFailure("p"), QueryParameterFailure, "p"},
+		{pg.MakeErrorQueryExecutionFailure("e"), QueryExecutionFailure, "e"},
+		{pg.MakeErrorQueryResponseFailure("r"), QueryResponseFailure, "r"},
+		{pg.MakeErrorOther("o"), Other, "o"},
+	}
+	for _, c := range cases {
+		err := pgError(c.raw).(*Error)
+		if err.Kind != c.kind || err.Message != c.msg {
+			t.Fatalf("mapping = kind %d msg %q, want kind %d msg %q", err.Kind, err.Message, c.kind, c.msg)
+		}
+	}
+}
diff --git a/sdks/go/golem/rdbms/types/types.go b/sdks/go/golem/rdbms/types/types.go
new file mode 100644
index 0000000000..f8a4c8a73a
--- /dev/null
+++ b/sdks/go/golem/rdbms/types/types.go
@@ -0,0 +1,128 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 types holds the temporal and network value types shared by the Golem
+// rdbms drivers (postgres today, mysql later). The everyday cases — timestamp,
+// timestamptz and date — round-trip through the standard library's time.Time
+// (see the driver's Row.Time getter); these structs exist for the cases time.Time
+// cannot hold on its own (a bare time of day, a time with an offset, an interval)
+// and for building typed parameters via the driver's constructors.
+package types
+
+import (
+	"fmt"
+	"time"
+)
+
+// Date is a calendar date with no time zone.
+type Date struct{ Year, Month, Day int }
+
+// DateOf takes the date part of t (in t's own location).
+func DateOf(t time.Time) Date {
+	y, m, d := t.Date()
+	return Date{Year: y, Month: int(m), Day: d}
+}
+
+// ToTime renders the date as midnight UTC.
+func (d Date) ToTime() time.Time {
+	return time.Date(d.Year, time.Month(d.Month), d.Day, 0, 0, 0, 0, time.UTC)
+}
+
+func (d Date) String() string { return fmt.Sprintf("%04d-%02d-%02d", d.Year, d.Month, d.Day) }
+
+// Time is a time of day with no time zone.
+type Time struct{ Hour, Minute, Second, Nanosecond int }
+
+// TimeOf takes the clock part of t (in t's own location).
+func TimeOf(t time.Time) Time {
+	return Time{Hour: t.Hour(), Minute: t.Minute(), Second: t.Second(), Nanosecond: t.Nanosecond()}
+}
+
+func (t Time) String() string {
+	return fmt.Sprintf("%02d:%02d:%02d.%09d", t.Hour, t.Minute, t.Second, t.Nanosecond)
+}
+
+// Timetz is a time of day with a UTC offset (seconds east of UTC).
+type Timetz struct {
+	Time          Time
+	OffsetSeconds int
+}
+
+// Timestamp is a date and time with no time zone.
+type Timestamp struct {
+	Date Date
+	Time Time
+}
+
+// TimestampOf splits t (in t's own location) into a Timestamp.
+func TimestampOf(t time.Time) Timestamp {
+	return Timestamp{Date: DateOf(t), Time: TimeOf(t)}
+}
+
+// ToTime renders the timestamp in UTC.
+func (ts Timestamp) ToTime() time.Time {
+	return time.Date(ts.Date.Year, time.Month(ts.Date.Month), ts.Date.Day,
+		ts.Time.Hour, ts.Time.Minute, ts.Time.Second, ts.Time.Nanosecond, time.UTC)
+}
+
+// Timestamptz is a Timestamp with a UTC offset (seconds east of UTC).
+type Timestamptz struct {
+	Timestamp     Timestamp
+	OffsetSeconds int
+}
+
+// TimestamptzOf splits t into a Timestamptz, preserving t's offset.
+func TimestamptzOf(t time.Time) Timestamptz {
+	_, off := t.Zone()
+	return Timestamptz{Timestamp: TimestampOf(t), OffsetSeconds: off}
+}
+
+// ToTime reconstructs the instant in a fixed zone matching the stored offset.
+func (ts Timestamptz) ToTime() time.Time {
+	loc := time.FixedZone("", ts.OffsetSeconds)
+	t := ts.Timestamp.ToTime()
+	return time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), loc)
+}
+
+// Interval is a Postgres interval: a whole number of months and days plus a
+// sub-day microsecond span.
+type Interval struct {
+	Months       int
+	Days         int
+	Microseconds int64
+}
+
+// MacAddr is a six-octet hardware address.
+type MacAddr [6]byte
+
+func (m MacAddr) String() string {
+	return fmt.Sprintf("%02x:%02x:%02x:%02x:%02x:%02x", m[0], m[1], m[2], m[3], m[4], m[5])
+}
+
+// ErrorKind classifies a database error. It is shared by the postgres and mysql
+// drivers, whose host error variants are identical.
+type ErrorKind uint8
+
+const (
+	// ConnectionFailure means the connection could not be established or was lost.
+	ConnectionFailure ErrorKind = iota
+	// QueryParameterFailure means a parameter could not be encoded for the query.
+	QueryParameterFailure
+	// QueryExecutionFailure means the database rejected or failed the statement.
+	QueryExecutionFailure
+	// QueryResponseFailure means the result could not be decoded.
+	QueryResponseFailure
+	// Other is any error the host did not classify.
+	Other
+)
diff --git a/sdks/go/golem/rdbms/types/types_test.go b/sdks/go/golem/rdbms/types/types_test.go
new file mode 100644
index 0000000000..bbed71cd27
--- /dev/null
+++ b/sdks/go/golem/rdbms/types/types_test.go
@@ -0,0 +1,63 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 types
+
+import (
+	"testing"
+	"time"
+)
+
+// TestTimestampOfToTime — time.Time round-trips through Timestamp (UTC).
+func TestTimestampOfToTime(t *testing.T) {
+	orig := time.Date(2026, 7, 30, 12, 34, 56, 789, time.UTC)
+	if got := TimestampOf(orig).ToTime(); !got.Equal(orig) {
+		t.Fatalf("Timestamp round-trip = %v, want %v", got, orig)
+	}
+}
+
+// TestTimestamptzOfToTime — Timestamptz preserves the offset.
+func TestTimestamptzOfToTime(t *testing.T) {
+	loc := time.FixedZone("", -5*3600)
+	orig := time.Date(2026, 1, 2, 3, 4, 5, 0, loc)
+	tz := TimestamptzOf(orig)
+	if tz.OffsetSeconds != -5*3600 {
+		t.Fatalf("offset = %d", tz.OffsetSeconds)
+	}
+	if got := tz.ToTime(); !got.Equal(orig) {
+		t.Fatalf("Timestamptz round-trip = %v, want %v", got, orig)
+	}
+}
+
+// TestDateStringAndTime — Date renders and converts as expected.
+func TestDateStringAndTime(t *testing.T) {
+	d := Date{Year: 2026, Month: 7, Day: 5}
+	if d.String() != "2026-07-05" {
+		t.Fatalf("Date.String = %q", d.String())
+	}
+	if tm := d.ToTime(); tm.Hour() != 0 || tm.Day() != 5 {
+		t.Fatalf("Date.ToTime = %v", tm)
+	}
+	if got := DateOf(time.Date(2026, 7, 5, 9, 0, 0, 0, time.UTC)); got != d {
+		t.Fatalf("DateOf = %+v", got)
+	}
+}
+
+// TestMacAddrString — canonical colon-separated hex.
+func TestMacAddrString(t *testing.T) {
+	m := MacAddr{0xde, 0xad, 0xbe, 0xef, 0x00, 0x01}
+	if m.String() != "de:ad:be:ef:00:01" {
+		t.Fatalf("MacAddr.String = %q", m.String())
+	}
+}
diff --git a/sdks/go/golem/readonly_test.go b/sdks/go/golem/readonly_test.go
new file mode 100644
index 0000000000..56a6a3578d
--- /dev/null
+++ b/sdks/go/golem/readonly_test.go
@@ -0,0 +1,100 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"testing"
+	"time"
+
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+)
+
+// TestReadOnlyLowering — read-only methods lower to AgentMethod.ReadOnly with the
+// right cache policy; a plain method stays read-write (None).
+func TestReadOnlyLowering(t *testing.T) {
+	type Id struct{ Name string }
+	type St struct{}
+	h := func(*Context[St], Unit) Unit { return Unit{} }
+
+	withDefs(t, func(d *definitions) {
+		a := defineAgentInto[Id, St](d, Spec{Name: "A"}, func(Id) *St { return &St{} })
+		def := func(name string, opts ...MethodOpt) {
+			implementInto[Id, St, NoConfig, Unit, Unit](d, a, DefineMethod[Id, Unit, Unit](name, opts...), h)
+		}
+		def("rw")                                     // read-write
+		def("ro", ReadOnly())                         // default => until-write
+		def("nc", ReadOnly(NoCache()))
+		def("uw", ReadOnly(CacheUntilWrite()))
+		def("ttl", ReadOnly(CacheFor(30*time.Second)))
+
+		types, errs := d.discover()
+		if len(errs) != 0 {
+			t.Fatalf("unexpected definition errors: %v", errs)
+		}
+		byName := map[string]common.AgentMethod{}
+		for _, m := range types[0].Methods {
+			byName[m.Name] = m
+		}
+
+		if byName["rw"].ReadOnly.IsSome() {
+			t.Fatal("rw should be read-write (ReadOnly None)")
+		}
+		wantPolicy := func(name string, tag uint8) common.CachePolicy {
+			m := byName[name]
+			if !m.ReadOnly.IsSome() {
+				t.Fatalf("%s should be read-only", name)
+			}
+			cp := m.ReadOnly.Some().CachePolicy
+			if cp.Tag() != tag {
+				t.Fatalf("%s cache tag = %d, want %d", name, cp.Tag(), tag)
+			}
+			return cp
+		}
+		wantPolicy("ro", common.CachePolicyUntilWrite)
+		wantPolicy("nc", common.CachePolicyNoCache)
+		wantPolicy("uw", common.CachePolicyUntilWrite)
+		if cp := wantPolicy("ttl", common.CachePolicyTtl); cp.Ttl() != uint64(30*time.Second.Nanoseconds()) {
+			t.Fatalf("ttl = %d ns, want %d", cp.Ttl(), uint64(30*time.Second.Nanoseconds()))
+		}
+	})
+}
+
+func TestReadOnlyMisuse(t *testing.T) {
+	type Id struct{ Name string }
+	type St struct{}
+	h := func(*Context[St], Unit) Unit { return Unit{} }
+
+	cases := []struct {
+		name   string
+		mode   Mode
+		method MethodDef[Id, Unit, Unit]
+		want   string
+	}{
+		{"repeated", Durable, DefineMethod[Id, Unit, Unit]("m", ReadOnly(), ReadOnly()), "ReadOnly set 2 times"},
+		{"two policies", Durable, DefineMethod[Id, Unit, Unit]("m", ReadOnly(NoCache(), CacheFor(time.Second))), "at most one cache policy"},
+		{"zero ttl", Durable, DefineMethod[Id, Unit, Unit]("m", ReadOnly(CacheFor(0))), "positive ttl"},
+		{"negative ttl", Durable, DefineMethod[Id, Unit, Unit]("m", ReadOnly(CacheFor(-time.Second))), "positive ttl"},
+		{"ephemeral", Ephemeral, DefineMethod[Id, Unit, Unit]("m", ReadOnly()), "only valid on a Durable agent"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			withDefs(t, func(d *definitions) {
+				a := defineAgentInto[Id, St](d, Spec{Name: "A", Mode: c.mode}, func(Id) *St { return &St{} })
+				implementInto[Id, St, NoConfig, Unit, Unit](d, a, c.method, h)
+				mustDefErr(t, d, c.want)
+			})
+		})
+	}
+}
diff --git a/sdks/go/golem/registry.go b/sdks/go/golem/registry.go
new file mode 100644
index 0000000000..065a1d6931
--- /dev/null
+++ b/sdks/go/golem/registry.go
@@ -0,0 +1,374 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"reflect"
+
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+)
+
+// fieldInfo is one exported struct field, in declaration order. Declaration
+// order is the wire order: value trees encode records positionally.
+type fieldInfo struct {
+	name  string
+	index int
+	typ   reflect.Type
+	codec *codec
+}
+
+type methodEntry struct {
+	name      string
+	desc      string
+	inFields  []fieldInfo
+	endpoints []Endpoint      // HTTP routes, if any
+	readOnly  *readOnlyConfig // non-nil => read-only method with a cache policy
+	outCodec  *codec          // nil => unit output
+	// invoke is the erased dispatcher produced by Implement. Calling it is a
+	// direct func-value call: no reflection is used to reach the handler.
+	invoke func(state any, agentID string, in types.SchemaValueTree) (out *types.SchemaValueTree, err error)
+}
+
+type agentEntry struct {
+	name     string
+	desc     string
+	mode     common.AgentMode
+	mount    *Mount         // HTTP mount, if any
+	snapshot SnapshotPolicy // snapshot cadence
+	configs  []configDecl   // declared config keys + secrets
+	idType   reflect.Type
+	idFields []fieldInfo
+	newState func(idVal reflect.Value, agentID string) any
+	methods  map[string]*methodEntry
+	order    []string
+}
+
+// instance is the single agent instance this worker runs. A component may define
+// many agent types, but a worker is initialized as exactly one of them — so the
+// live state is held here rather than on the (shared, immutable) type entry.
+type instance struct {
+	def     *agentEntry
+	state   any
+	agentID string
+	// config is the agent's materialized config (its Cfg value), cached for the
+	// worker's life on first read. Its local fields are read from the host once;
+	// its secret fields are lazy handles that re-read on Secret.Get(). nil until
+	// the first Config/InitContext.Config call.
+	config any
+}
+
+// active is the running instance this worker was initialized as, or nil before
+// initialize() has run. Unlike the definition state (see [definitions]) this is
+// per-worker runtime state, so it stays a standalone package var.
+var active *instance
+
+// structFields returns the exported fields of a struct type in declaration
+// order. Non-structs (e.g. Unit) yield no fields.
+func (d *definitions) structFields(t reflect.Type) []fieldInfo {
+	var out []fieldInfo
+	if t == nil || t.Kind() != reflect.Struct {
+		return out
+	}
+	for i := range t.NumField() {
+		f := t.Field(i)
+		if f.PkgPath != "" { // unexported
+			continue
+		}
+		out = append(out, fieldInfo{
+			name:  lowerFirst(f.Name),
+			index: i,
+			typ:   f.Type,
+			codec: d.compile(f.Type),
+		})
+	}
+	return out
+}
+
+func lowerFirst(s string) string {
+	if s == "" {
+		return s
+	}
+	b := []byte(s)
+	if b[0] >= 'A' && b[0] <= 'Z' {
+		b[0] += 'a' - 'A'
+	}
+	return string(b)
+}
+
+// DefineAgent registers an agent type and returns its typed handle. init builds
+// the instance state from the constructor parameters.
+//
+// Call it from a package-level var so registration happens before the component
+// is invoked.
+//
+// A config-less agent uses this form. To attach config — whether the constructor
+// needs it or only the methods do — declare the agent with [DefineConfiguredAgent]
+// and read it with [Agent.Config].
+//
+// This is sugar over [DefineConfiguredAgent] with [NoConfig]: the constructor
+// gets its id directly and never sees [InitContext].
+func DefineAgent[Id any, S any](spec Spec, init func(Id) *S) *Agent[Id, S, NoConfig] {
+	return defineAgentInto[Id, S](defs, spec, init)
+}
+
+// defineAgentInto is the instance-scoped form of DefineAgent — sugar over
+// [defineConfiguredAgentInto] with [NoConfig], adapting the simple func(Id) *S
+// constructor. Tests call it with their own definitions for full isolation.
+func defineAgentInto[Id any, S any](d *definitions, spec Spec, init func(Id) *S) *Agent[Id, S, NoConfig] {
+	var cinit func(*InitContext[Id, S, NoConfig]) *S
+	if init != nil {
+		cinit = func(ctx *InitContext[Id, S, NoConfig]) *S { return init(ctx.id) }
+	}
+	return defineConfiguredAgentInto[Id, S, NoConfig](d, spec, cinit)
+}
+
+// DefineConfiguredAgent registers an agent with config type Cfg and returns its
+// handle. Cfg is carried on the handle, so config is read in a method with
+// [Agent.Config] — no separate config handle. init receives an
+// *[InitContext][Id, S, Cfg], which carries the constructor parameters
+// ([InitContext.ID]) and reads config with [InitContext.Config] — off the
+// context, not the returned agent, so the constructor does not self-reference the
+// package-level var it is being assigned to:
+//
+//	var Shop = golem.DefineConfiguredAgent[ShopId, ShopState, ShopConfig](
+//	    golem.Spec{Name: "Shop"},
+//	    func(ctx *golem.InitContext[ShopId, ShopState, ShopConfig]) *ShopState {
+//	        return &ShopState{greeting: ctx.Config().Greeting}
+//	    },
+//	)
+//
+// Methods take *[Context] and read config with Shop.Config(ctx). An agent whose
+// constructor does not need config can ignore the InitContext's config; an agent
+// with no config at all uses the simpler [DefineAgent].
+func DefineConfiguredAgent[Id any, S any, Cfg any](spec Spec, init func(*InitContext[Id, S, Cfg]) *S) *Agent[Id, S, Cfg] {
+	return defineConfiguredAgentInto[Id, S, Cfg](defs, spec, init)
+}
+
+// defineConfiguredAgentInto is the instance-scoped implementation behind both
+// DefineAgent and DefineConfiguredAgent. The public entry points wrap it against
+// the package-global defs; tests call it with their own definitions for full
+// isolation. (It must stay a generic function — Go forbids generic methods.)
+func defineConfiguredAgentInto[Id any, S any, Cfg any](d *definitions, spec Spec, init func(*InitContext[Id, S, Cfg]) *S) *Agent[Id, S, Cfg] {
+	idType := reflect.TypeFor[Id]()
+	if spec.Name == "" {
+		d.recordErr("", "", "DefineAgent requires a non-empty Spec.Name (Id type %s)", idType)
+		return &Agent[Id, S, Cfg]{name: spec.Name}
+	}
+	if _, dup := d.agents[spec.Name]; dup {
+		d.recordErr(spec.Name, "", "agent type already defined")
+		return &Agent[Id, S, Cfg]{name: spec.Name}
+	}
+	if idType.Kind() != reflect.Struct {
+		// Record but still register (with no id fields) so downstream Implement
+		// calls attach rather than cascading into "unknown agent" errors.
+		d.recordErr(spec.Name, "", "Id must be a struct, got %s", idType)
+	}
+	if init == nil {
+		// Recorded, not fatal: init is only called from a successful initialize,
+		// which is gated on this agent having no definition errors — so the nil is
+		// reported at discovery rather than panicking at construction time.
+		d.recordErr(spec.Name, "", "DefineAgent requires a non-nil init function")
+	}
+	e := &agentEntry{
+		name:     spec.Name,
+		desc:     spec.Description,
+		mode:     spec.Mode.toWit(),
+		mount:    spec.HTTP,
+		snapshot: spec.Snapshot,
+		idType:   idType,
+		idFields: d.structFields(idType),
+		methods:  map[string]*methodEntry{},
+		newState: func(idVal reflect.Value, agentID string) any {
+			// No host call here: the constructor reads config lazily via
+			// ctx.Config(), keeping get-config-value out of this always-linked path
+			// (it must stay reachable only from wasm, like Agent.Config).
+			return init(&InitContext[Id, S, Cfg]{id: idVal.Interface().(Id), agentID: agentID})
+		},
+	}
+	d.agents[spec.Name] = e
+	d.order = append(d.order, spec.Name)
+	// Attach Cfg's config surface. NoConfig (the DefineAgent path) has no fields,
+	// so this records nothing. Done after registration so it lands on the live
+	// entry.
+	flattenConfigStruct(d, e, spec.Name, reflect.TypeFor[Cfg]())
+	// The Id type identifies the target agent for typed calls (ClientFor), so two
+	// agents cannot share one — the second would silently shadow the first.
+	if existing, ok := d.idToAgent[idType]; ok && existing != spec.Name {
+		d.recordErr(spec.Name, "", "Id type %s is already used by agent %q; each agent needs a distinct Id type", idType, existing)
+	} else {
+		d.idToAgent[idType] = spec.Name
+	}
+	return &Agent[Id, S, Cfg]{name: spec.Name}
+}
+
+// DefineMethod declares a typed method descriptor. The type parameters are
+// explicit because none can be inferred from the arguments:
+//
+//	var Add = golem.DefineMethod[CounterId, AddIn, int64]("add")
+func DefineMethod[Id any, In any, Out any](name string, opts ...MethodOpt) MethodDef[Id, In, Out] {
+	var o methodOpts
+	for _, f := range opts {
+		f(&o)
+	}
+	// descCount is carried on the descriptor and validated at Implement time,
+	// where the target definitions is known — DefineMethod itself is instance
+	// independent (it just returns a descriptor).
+	return MethodDef[Id, In, Out]{
+		name: name, desc: o.desc, descCount: o.descCount, endpoints: o.endpoints,
+		readOnly: o.readOnly, readOnlyCount: o.readOnlyCount, cacheCount: o.cacheCount,
+	}
+}
+
+// Implement binds a handler to a method descriptor. S, In and Out are inferred
+// from the handler, and Id must match the agent — so binding a descriptor to the
+// wrong agent, or a handler with the wrong signature, is a compile error.
+//
+// The handler is wrapped once, here, into a uniform dispatcher; dispatch itself
+// never uses reflection to call user code.
+// A handler returns only its output value. There is no error return: a failed
+// invocation is signalled by panicking (the SDK recovers it into a non-retriable
+// agent-error surfaced to the caller — the worker survives). Reserve panic for
+// genuine failures; model expected, typed outcomes as a [Result] in the output.
+// Use [Must] to turn an inner (value, error) call into a panic-on-error.
+//
+// Thin wrapper over the package-global defs — keep all logic in [implementInto]
+// so it stays testable against an explicit *definitions. See [defs].
+func Implement[Id any, S any, Cfg any, In any, Out any](
+	a *Agent[Id, S, Cfg],
+	m MethodDef[Id, In, Out],
+	h func(*Context[S], In) Out,
+) {
+	implementInto[Id, S, Cfg, In, Out](defs, a, m, h)
+}
+
+// implementInto is the instance-scoped implementation behind Implement.
+func implementInto[Id any, S any, Cfg any, In any, Out any](
+	d *definitions,
+	a *Agent[Id, S, Cfg],
+	m MethodDef[Id, In, Out],
+	h func(*Context[S], In) Out,
+) {
+	e := d.agents[a.name]
+	if e == nil {
+		d.recordErr(a.name, m.name, "Implement: unknown agent %q (was DefineAgent called?)", a.name)
+		return
+	}
+	if m.name == "" {
+		d.recordErr(a.name, "", "DefineMethod requires a non-empty method name")
+		return
+	}
+	if h == nil {
+		d.recordErr(a.name, m.name, "Implement requires a non-nil handler")
+		return
+	}
+	if m.descCount > 1 {
+		d.recordErr(a.name, m.name, "method %q: Desc set %d times (a method has one description)", m.name, m.descCount)
+	}
+	if m.readOnlyCount > 1 {
+		d.recordErr(a.name, m.name, "method %q: ReadOnly set %d times (a method is read-only once)", m.name, m.readOnlyCount)
+	}
+	if m.cacheCount > 1 {
+		d.recordErr(a.name, m.name, "method %q: ReadOnly accepts at most one cache policy, got %d", m.name, m.cacheCount)
+	}
+	if m.readOnly != nil {
+		if m.readOnly.policy.kind == cacheTTL && m.readOnly.policy.ttl <= 0 {
+			d.recordErr(a.name, m.name, "method %q: CacheFor requires a positive ttl, got %v (use NoCache to disable caching)", m.name, m.readOnly.policy.ttl)
+		}
+		if e.mode == common.AgentModeEphemeral {
+			d.recordErr(a.name, m.name, "method %q: ReadOnly is only valid on a Durable agent (an ephemeral agent has no shared state to cache)", m.name)
+		}
+	}
+	if _, dup := e.methods[m.name]; dup {
+		d.recordErr(a.name, m.name, "method already implemented")
+		return
+	}
+
+	// Codecs are compiled once, here at registration — not per invocation.
+	inType := reflect.TypeFor[In]()
+	outType := reflect.TypeFor[Out]()
+	me := &methodEntry{name: m.name, desc: m.desc, inFields: d.structFields(inType), endpoints: m.endpoints, readOnly: m.readOnly}
+	if outType != reflect.TypeFor[Unit]() {
+		me.outCodec = d.compile(outType)
+	}
+
+	me.invoke = func(state any, agentID string, tree types.SchemaValueTree) (out *types.SchemaValueTree, err error) {
+		// Panic hardening: a panic becomes an agent-error instead of killing the
+		// component. stage attributes it, so an SDK bug is not reported as if it
+		// were the agent's fault.
+		stage := stageDecode
+		defer func() {
+			if r := recover(); r != nil {
+				out, err = nil, &PanicError{Method: me.name, Stage: stage, Value: r}
+			}
+		}()
+
+		inVal := reflect.New(inType).Elem()
+		if derr := decodeParams(tree, me.inFields, inVal); derr != nil {
+			return nil, &decodeError{derr.Error()}
+		}
+
+		stage = stageHandler
+		ctx := &Context[S]{State: state.(*S), agentID: agentID}
+		result := h(ctx, inVal.Interface().(In))
+		if me.outCodec == nil {
+			return nil, nil
+		}
+
+		stage = stageEncode
+		// &result, not result: reflect.ValueOf unwraps an interface to the
+		// concrete type it holds, which would lose the declared type of a
+		// variant-typed output.
+		encoded := encodeWith(me.outCodec, reflect.ValueOf(&result).Elem())
+		return &encoded, nil
+	}
+
+	e.methods[m.name] = me
+	e.order = append(e.order, m.name)
+}
+
+// ---------------------------------------------------------------------------
+// Method-expression binding
+//
+// A Go method expression ((*S).Method) is a typed func value whose first
+// argument is the receiver, so these adapters allow authoring agents as ordinary
+// Go methods with full compile-time checking and no reflection:
+//
+//	func (s *CartState) AddItem(in AddItemIn) int64 { ... }
+//	golem.Implement(Cart, CartAdd, golem.Bind((*CartState).AddItem))
+//
+// Methods signal failure by panicking, like any handler. Go has no overloading,
+// so there is one adapter per method shape: `0` = no input, `Unit` = no output.
+// ---------------------------------------------------------------------------
+
+// Bind adapts func(*S, In) Out — the canonical shape.
+func Bind[S, In, Out any](m func(*S, In) Out) func(*Context[S], In) Out {
+	return func(ctx *Context[S], in In) Out { return m(ctx.State, in) }
+}
+
+// Bind0 adapts func(*S) Out — no input.
+func Bind0[S, Out any](m func(*S) Out) func(*Context[S], Unit) Out {
+	return func(ctx *Context[S], _ Unit) Out { return m(ctx.State) }
+}
+
+// BindUnit adapts func(*S, In) — no output.
+func BindUnit[S, In any](m func(*S, In)) func(*Context[S], In) Unit {
+	return func(ctx *Context[S], in In) Unit { m(ctx.State, in); return Unit{} }
+}
+
+// Bind0Unit adapts func(*S) — neither input nor output.
+func Bind0Unit[S any](m func(*S)) func(*Context[S], Unit) Unit {
+	return func(ctx *Context[S], _ Unit) Unit { m(ctx.State); return Unit{} }
+}
diff --git a/sdks/go/golem/registry_test.go b/sdks/go/golem/registry_test.go
new file mode 100644
index 0000000000..1fa8d13018
--- /dev/null
+++ b/sdks/go/golem/registry_test.go
@@ -0,0 +1,73 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestBindAdapters(t *testing.T) {
+	type S struct{ n int }
+	ctx := &Context[S]{State: &S{}}
+
+	add := Bind(func(s *S, in int) int { s.n += in; return s.n })
+	if got := add(ctx, 5); got != 5 || ctx.State.n != 5 {
+		t.Fatalf("Bind = %d, state %d", got, ctx.State.n)
+	}
+	get := Bind0(func(s *S) int { return s.n })
+	if got := get(ctx, Unit{}); got != 5 {
+		t.Fatalf("Bind0 = %d", got)
+	}
+	set := BindUnit(func(s *S, in int) { s.n = in })
+	if set(ctx, 9); ctx.State.n != 9 {
+		t.Fatalf("BindUnit state = %d", ctx.State.n)
+	}
+	clear := Bind0Unit(func(s *S) { s.n = 0 })
+	if clear(ctx, Unit{}); ctx.State.n != 0 {
+		t.Fatalf("Bind0Unit state = %d", ctx.State.n)
+	}
+}
+
+func TestStructFieldsAndLowerFirst(t *testing.T) {
+	if fs := defs.structFields(reflect.TypeFor[int]()); len(fs) != 0 {
+		t.Fatalf("non-struct should yield no fields, got %d", len(fs))
+	}
+	type withUnexported struct {
+		Exported   string
+		unexported int //nolint:unused // present to exercise the skip path
+	}
+	_ = withUnexported{}.unexported
+	fs := defs.structFields(reflect.TypeFor[withUnexported]())
+	if len(fs) != 1 || fs[0].name != "exported" {
+		t.Fatalf("fields = %+v", fs)
+	}
+	if lowerFirst("") != "" {
+		t.Fatal("lowerFirst(\"\") should be empty")
+	}
+}
+
+func TestRegistrationErrorsAreRecorded(t *testing.T) {
+	type Id struct{ Name string }
+	type St struct{}
+	withDefs(t, func(d *definitions) {
+		defineAgentInto[Id, St](d, Spec{}, func(Id) *St { return &St{} })
+		implementInto[Id, St, NoConfig, Unit, Unit](d, &Agent[Id, St, NoConfig]{name: "does-not-exist"},
+			MethodDef[Id, Unit, Unit]{name: "m"},
+			func(*Context[St], Unit) Unit { return Unit{} })
+		mustDefErr(t, d, "non-empty Spec.Name")
+		mustDefErr(t, d, "unknown agent")
+	})
+}
diff --git a/sdks/go/golem/retry/retry.go b/sdks/go/golem/retry/retry.go
new file mode 100644
index 0000000000..5d348d3568
--- /dev/null
+++ b/sdks/go/golem/retry/retry.go
@@ -0,0 +1,988 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 retry is a builder for Golem retry policies.
+//
+// Golem retries retriable operations (RPC, HTTP, RDBMS, and whole-invocation
+// traps) according to named policy rules. Each rule is a [NamedPolicy]: a
+// [Policy] (the retry strategy) plus a [Predicate] deciding when the rule
+// applies and a priority. The runtime resolves, per operation, the
+// highest-priority rule whose predicate matches, and applies its policy.
+//
+// Build a strategy from a base ([Exponential], [Periodic], [Fibonacci],
+// [Immediate], [Never]) and refine it with fluent combinators:
+//
+//	pol := retry.Exponential(200*time.Millisecond, 2.0).
+//		Clamp(100*time.Millisecond, 5*time.Second).
+//		OnlyWhen(retry.StatusCode.OneOf(502, 503, 504)).
+//		MaxRetries(3)
+//	retry.Set(retry.Named("transient-http", pol).
+//		WithPriority(10).
+//		AppliesWhen(retry.Verb.Eq("GET")))
+//
+// A [Policy]/[Predicate]/[NamedPolicy] is an immutable value; combinators return
+// a new value. The underlying wire form is an index-referenced node graph, but
+// that is only ever produced by lowering — you compose values, never indices, so
+// malformed graphs are unrepresentable. Value-range mistakes (a non-positive
+// exponential factor, min > max in Clamp, a negative duration, an out-of-range
+// integer, a zero-value tree) are reported: [Set] and [With] fail loud (panic)
+// on an invalid policy, while [NamedPolicy.Validate] returns the error instead.
+//
+// # Where policies come from
+//
+// Base rules are usually declared in the application manifest (golem.yaml
+// retryPolicyDefaults) or via the CLI/REST API; those are managed by the operator
+// and stay live (the host refreshes them, like secrets), and this package reads
+// them back with [GetPolicies], [GetByName], [Resolve] and [PolicyNames]. From
+// agent code you overlay them: [Set] registers a rule that persists (and takes
+// precedence over a live rule of the same name — use it when the code owns that
+// rule), while [With] applies a rule only for the current call and restores the
+// previous one on return. A common split: manifest for operator-tunable base
+// rules, [Set] in the constructor for code-owned rules, [With] for per-call tweaks.
+//
+// # Concurrency
+//
+// [Set], [Remove] and [With] apply at the worker level — the retry scope is
+// currently per worker rather than per goroutine (the same model as the other
+// Golem SDKs). Golem runs an agent single-threaded with cooperative
+// task-switching only at await points (RPC, promise, sleep), so [With] is safe
+// when its scope does not await while other goroutines run concurrently; nesting
+// on a single logical flow is fine. To keep an override from affecting concurrent
+// work, don't hold a scope open across a concurrent await (e.g. a CallAsync
+// fan-out); for concurrency, distribute work across agent instances.
+package retry
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"time"
+
+	apiRetry "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_retry"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// ── Policy: immutable retry-strategy tree ────────────────────────────────────
+
+type policyKind uint8
+
+const (
+	pkPeriodic policyKind = iota
+	pkExponential
+	pkFibonacci
+	pkImmediate
+	pkNever
+	pkCountBox
+	pkTimeBox
+	pkClampDelay
+	pkAddDelay
+	pkJitter
+	pkFilteredOn
+	pkAndThen
+	pkUnion
+	pkIntersect
+)
+
+// policyNode is the unexported tree node. Field use is per-kind (documented at
+// each constructor); unused fields stay zero. Children are pointers so the graph
+// is a value tree the user composes without ever seeing an index.
+type policyNode struct {
+	kind     policyKind
+	d1       time.Duration // periodic delay | exponential base | fibonacci first | timeBox limit | clamp min | addDelay delay
+	d2       time.Duration // fibonacci second | clamp max
+	factor   float64       // exponential factor | jitter factor
+	maxTries uint32        // countBox
+	inner    *policyNode   // countBox/timeBox/clamp/addDelay/jitter/filteredOn child
+	left     *policyNode   // andThen/union/intersect
+	right    *policyNode
+	pred     *predicateNode // filteredOn
+}
+
+// Policy is an immutable retry strategy. Its zero value is invalid; build one
+// with a constructor.
+type Policy struct{ node *policyNode }
+
+// Periodic retries with a fixed delay between attempts.
+func Periodic(d time.Duration) Policy {
+	return Policy{&policyNode{kind: pkPeriodic, d1: d}}
+}
+
+// Exponential retries with an exponentially growing delay: base, base*factor,
+// base*factor^2, … factor must be finite and > 0.
+func Exponential(base time.Duration, factor float64) Policy {
+	return Policy{&policyNode{kind: pkExponential, d1: base, factor: factor}}
+}
+
+// Fibonacci retries with a Fibonacci-growing delay seeded by first and second.
+func Fibonacci(first, second time.Duration) Policy {
+	return Policy{&policyNode{kind: pkFibonacci, d1: first, d2: second}}
+}
+
+// Immediate retries with no delay.
+func Immediate() Policy { return Policy{&policyNode{kind: pkImmediate}} }
+
+// Never does not retry.
+func Never() Policy { return Policy{&policyNode{kind: pkNever}} }
+
+// MaxRetries caps the number of retries.
+func (p Policy) MaxRetries(n uint32) Policy {
+	return Policy{&policyNode{kind: pkCountBox, maxTries: n, inner: p.node}}
+}
+
+// Within stops retrying once the given wall-clock budget has elapsed.
+func (p Policy) Within(d time.Duration) Policy {
+	return Policy{&policyNode{kind: pkTimeBox, d1: d, inner: p.node}}
+}
+
+// Clamp bounds each computed delay to [minDelay, maxDelay]. minDelay must be <= maxDelay.
+func (p Policy) Clamp(minDelay, maxDelay time.Duration) Policy {
+	return Policy{&policyNode{kind: pkClampDelay, d1: minDelay, d2: maxDelay, inner: p.node}}
+}
+
+// AddDelay adds a fixed delay to each computed delay.
+func (p Policy) AddDelay(d time.Duration) Policy {
+	return Policy{&policyNode{kind: pkAddDelay, d1: d, inner: p.node}}
+}
+
+// WithJitter randomizes each delay by up to the given factor. factor must be
+// finite and >= 0.
+func (p Policy) WithJitter(factor float64) Policy {
+	return Policy{&policyNode{kind: pkJitter, factor: factor, inner: p.node}}
+}
+
+// OnlyWhen applies this strategy only when pred matches the operation context.
+func (p Policy) OnlyWhen(pred Predicate) Policy {
+	return Policy{&policyNode{kind: pkFilteredOn, pred: pred.node, inner: p.node}}
+}
+
+// AndThen falls back to next once this policy stops retrying.
+func (p Policy) AndThen(next Policy) Policy {
+	return Policy{&policyNode{kind: pkAndThen, left: p.node, right: next.node}}
+}
+
+// Union retries if either policy would retry (the shorter delay wins).
+func (p Policy) Union(other Policy) Policy {
+	return Policy{&policyNode{kind: pkUnion, left: p.node, right: other.node}}
+}
+
+// Intersect retries only if both policies would retry (the longer delay wins).
+func (p Policy) Intersect(other Policy) Policy {
+	return Policy{&policyNode{kind: pkIntersect, left: p.node, right: other.node}}
+}
+
+// ── Predicate: immutable match tree over the retry-context vocabulary ─────────
+
+// PropName is a retry-context property. The exported constants are the platform
+// vocabulary; use [Prop] for any other property name.
+type PropName string
+
+const (
+	Verb              PropName = "verb"
+	NounURI           PropName = "noun-uri"
+	URIScheme         PropName = "uri-scheme"
+	URIHost           PropName = "uri-host"
+	URIPort           PropName = "uri-port"
+	URIPath           PropName = "uri-path"
+	StatusCode        PropName = "status-code"
+	ErrorType         PropName = "error-type"
+	Function          PropName = "function"
+	TargetComponentID PropName = "target-component-id"
+	TargetAgentType   PropName = "target-agent-type"
+	DBType            PropName = "db-type"
+	TrapType          PropName = "trap-type"
+)
+
+// Prop names a custom retry-context property not covered by the constants above.
+func Prop(name string) PropName { return PropName(name) }
+
+type predKind uint8
+
+const (
+	prEq predKind = iota
+	prNeq
+	prGt
+	prGte
+	prLt
+	prLte
+	prExists
+	prIn
+	prMatches
+	prStartsWith
+	prContains
+	prAnd
+	prOr
+	prNot
+	prTrue
+	prFalse
+)
+
+type predicateNode struct {
+	kind  predKind
+	prop  string // property name (comparisons/exists/in/patterns)
+	val   any    // comparison value (eq/neq/gt/gte/lt/lte)
+	vals  []any  // OneOf values
+	pat   string // matches/startsWith/contains
+	left  *predicateNode
+	right *predicateNode
+	inner *predicateNode // Not
+}
+
+// Predicate is an immutable boolean match over the operation context. Its zero
+// value is invalid; build one from a [PropName] method or [MatchAlways]/
+// [MatchNever]. Predicate values may be string, any integer type, or bool.
+type Predicate struct{ node *predicateNode }
+
+func (p PropName) cmp(kind predKind, v any) Predicate {
+	return Predicate{&predicateNode{kind: kind, prop: string(p), val: v}}
+}
+
+// Eq matches when the property equals v.
+func (p PropName) Eq(v any) Predicate { return p.cmp(prEq, v) }
+
+// Neq matches when the property does not equal v.
+func (p PropName) Neq(v any) Predicate { return p.cmp(prNeq, v) }
+
+// Gt matches when the property is greater than v.
+func (p PropName) Gt(v any) Predicate { return p.cmp(prGt, v) }
+
+// Gte matches when the property is greater than or equal to v.
+func (p PropName) Gte(v any) Predicate { return p.cmp(prGte, v) }
+
+// Lt matches when the property is less than v.
+func (p PropName) Lt(v any) Predicate { return p.cmp(prLt, v) }
+
+// Lte matches when the property is less than or equal to v.
+func (p PropName) Lte(v any) Predicate { return p.cmp(prLte, v) }
+
+// Exists matches when the property is present in the context.
+func (p PropName) Exists() Predicate {
+	return Predicate{&predicateNode{kind: prExists, prop: string(p)}}
+}
+
+// OneOf matches when the property equals any of the given values.
+func (p PropName) OneOf(vs ...any) Predicate {
+	return Predicate{&predicateNode{kind: prIn, prop: string(p), vals: vs}}
+}
+
+// MatchesGlob matches when the property matches the glob pattern.
+func (p PropName) MatchesGlob(pattern string) Predicate {
+	return Predicate{&predicateNode{kind: prMatches, prop: string(p), pat: pattern}}
+}
+
+// StartsWith matches when the property starts with prefix.
+func (p PropName) StartsWith(prefix string) Predicate {
+	return Predicate{&predicateNode{kind: prStartsWith, prop: string(p), pat: prefix}}
+}
+
+// Contains matches when the property contains sub.
+func (p PropName) Contains(sub string) Predicate {
+	return Predicate{&predicateNode{kind: prContains, prop: string(p), pat: sub}}
+}
+
+// And matches when both predicates match.
+func (p Predicate) And(q Predicate) Predicate {
+	return Predicate{&predicateNode{kind: prAnd, left: p.node, right: q.node}}
+}
+
+// Or matches when either predicate matches.
+func (p Predicate) Or(q Predicate) Predicate {
+	return Predicate{&predicateNode{kind: prOr, left: p.node, right: q.node}}
+}
+
+// Not negates the predicate.
+func (p Predicate) Not() Predicate {
+	return Predicate{&predicateNode{kind: prNot, inner: p.node}}
+}
+
+// MatchAlways always matches (the default applicability of a [NamedPolicy]).
+func MatchAlways() Predicate { return Predicate{&predicateNode{kind: prTrue}} }
+
+// MatchNever never matches.
+func MatchNever() Predicate { return Predicate{&predicateNode{kind: prFalse}} }
+
+// ── NamedPolicy ──────────────────────────────────────────────────────────────
+
+// NamedPolicy is a retry rule: a [Policy], the [Predicate] that selects when it
+// applies, and a priority (higher is checked first). Build with [Named].
+type NamedPolicy struct {
+	name     string
+	priority uint32
+	applies  Predicate // zero => MatchAlways
+	policy   Policy
+}
+
+// Named creates a rule with priority 0 that always applies.
+func Named(name string, policy Policy) NamedPolicy {
+	return NamedPolicy{name: name, policy: policy}
+}
+
+// WithPriority sets the evaluation priority (higher is checked first).
+func (n NamedPolicy) WithPriority(p uint32) NamedPolicy { n.priority = p; return n }
+
+// AppliesWhen restricts the rule to contexts matching pred.
+func (n NamedPolicy) AppliesWhen(pred Predicate) NamedPolicy { n.applies = pred; return n }
+
+// Name returns the rule name.
+func (n NamedPolicy) Name() string { return n.name }
+
+// Priority returns the evaluation priority.
+func (n NamedPolicy) Priority() uint32 { return n.priority }
+
+// Strategy returns the retry [Policy] of the rule. The returned [Policy] is
+// opaque — re-apply or re-inspect via [Set]/[NamedPolicy.Validate], not
+// field-by-field.
+func (n NamedPolicy) Strategy() Policy { return n.policy }
+
+// Applicability returns the [Predicate] selecting when the rule applies
+// ([MatchAlways] if none was set).
+func (n NamedPolicy) Applicability() Predicate {
+	if n.applies.node == nil {
+		return MatchAlways()
+	}
+	return n.applies
+}
+
+// Validate reports whether the rule lowers to a valid wire policy, returning the
+// first problem found (nil if valid). It is the non-panicking counterpart to the
+// checks [Set] and [With] perform.
+func (n NamedPolicy) Validate() error {
+	if _, err := n.lower(); err != nil {
+		return fmt.Errorf("golem/retry: %w", err)
+	}
+	return nil
+}
+
+// ── Apply / scope (worker-global; see the package "Concurrency" note) ─────────
+
+// Set registers or overwrites the named rule and PERSISTS it for this agent (to
+// the oplog) — it stays in effect across invocations and takes precedence over a
+// manifest/CLI rule of the same name (so that name no longer tracks live updates).
+// Reach for it when the code owns the rule; prefer the manifest for operator-
+// tunable base rules, and [With] for a change scoped to one call. Panics if the
+// policy is invalid; use [NamedPolicy.Validate] to check first.
+func Set(n NamedPolicy) {
+	raw, err := n.lower()
+	if err != nil {
+		panic(fmt.Errorf("golem/retry: %w", err))
+	}
+	apiRetry.SetRetryPolicy(raw)
+}
+
+// Remove deletes the named rule.
+func Remove(name string) { apiRetry.RemoveRetryPolicy(name) }
+
+// With applies the rule for the current call only and returns a function that
+// restores the previously registered rule of the same name (or removes it if
+// there was none). Use it with defer to scope a per-invocation override:
+// defer retry.With(n)(). Because invocations run sequentially, the override does
+// not affect the next invocation. Panics if invalid. See the package "Concurrency"
+// note before using it across an await.
+func With(n NamedPolicy) (restore func()) {
+	raw, err := n.lower()
+	if err != nil {
+		panic(fmt.Errorf("golem/retry: %w", err))
+	}
+	name := n.name
+	prev := apiRetry.GetRetryPolicyByName(name)
+	apiRetry.SetRetryPolicy(raw)
+	return func() {
+		if prev.IsSome() {
+			apiRetry.SetRetryPolicy(prev.Some())
+		} else {
+			apiRetry.RemoveRetryPolicy(name)
+		}
+	}
+}
+
+// PolicyNames returns the names of the rules active for this agent (the built-in
+// "default" plus any registered). Cheap: it does not decode the policy bodies.
+func PolicyNames() []string {
+	raw := apiRetry.GetRetryPolicies()
+	names := make([]string, len(raw))
+	for i, p := range raw {
+		names[i] = p.Name
+	}
+	return names
+}
+
+// GetPolicies returns the rules active for this agent, decoded into [NamedPolicy]
+// values. It errors if the host returned a malformed policy graph.
+func GetPolicies() ([]NamedPolicy, error) {
+	raw := apiRetry.GetRetryPolicies()
+	out := make([]NamedPolicy, 0, len(raw))
+	for _, r := range raw {
+		np, err := decodeNamed(r)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, np)
+	}
+	return out, nil
+}
+
+// GetByName returns the rule with the given name. found is false if no such rule
+// exists; err is non-nil only if the host returned a malformed policy graph.
+func GetByName(name string) (policy NamedPolicy, found bool, err error) {
+	opt := apiRetry.GetRetryPolicyByName(name)
+	if opt.IsNone() {
+		return NamedPolicy{}, false, nil
+	}
+	np, err := decodeNamed(opt.Some())
+	if err != nil {
+		return NamedPolicy{}, true, err
+	}
+	return np, true, nil
+}
+
+// Resolve returns the [Policy] the runtime would apply to an operation with the
+// given verb, noun URI and context properties (the highest-priority matching
+// rule). matched is false if no rule matches.
+func Resolve(verb, nounURI string, props map[string]any) (policy Policy, matched bool, err error) {
+	tuples := make([]witTypes.Tuple2[string, apiRetry.PredicateValue], 0, len(props))
+	for k, v := range props {
+		pv, cErr := toPredicateValue(v)
+		if cErr != nil {
+			return Policy{}, false, cErr
+		}
+		tuples = append(tuples, witTypes.Tuple2[string, apiRetry.PredicateValue]{F0: k, F1: pv})
+	}
+	opt := apiRetry.ResolveRetryPolicy(verb, nounURI, tuples)
+	if opt.IsNone() {
+		return Policy{}, false, nil
+	}
+	pol, dErr := decodePolicy(opt.Some())
+	if dErr != nil {
+		return Policy{}, true, dErr
+	}
+	return pol, true, nil
+}
+
+// ── Lowering (value tree -> flattened index graph); pure, no host calls ───────
+
+func (n NamedPolicy) lower() (apiRetry.NamedRetryPolicy, error) {
+	pol, err := n.policy.lower()
+	if err != nil {
+		return apiRetry.NamedRetryPolicy{}, err
+	}
+	applies := n.applies
+	if applies.node == nil {
+		applies = MatchAlways()
+	}
+	pred, err := applies.lower()
+	if err != nil {
+		return apiRetry.NamedRetryPolicy{}, err
+	}
+	return apiRetry.NamedRetryPolicy{Name: n.name, Priority: n.priority, Predicate: pred, Policy: pol}, nil
+}
+
+func (p Policy) lower() (apiRetry.RetryPolicy, error) {
+	if p.node == nil {
+		return apiRetry.RetryPolicy{}, errors.New("invalid (zero) Policy; build one with a constructor such as retry.Exponential or retry.Periodic")
+	}
+	var nodes []apiRetry.PolicyNode
+	if _, err := pushPolicy(p.node, &nodes); err != nil {
+		return apiRetry.RetryPolicy{}, err
+	}
+	return apiRetry.RetryPolicy{Nodes: nodes}, nil
+}
+
+func pushPolicy(n *policyNode, nodes *[]apiRetry.PolicyNode) (int32, error) {
+	if n == nil {
+		return 0, errors.New("incomplete Policy: a combinator was applied to a zero Policy")
+	}
+	idx := int32(len(*nodes))
+	*nodes = append(*nodes, apiRetry.MakePolicyNodeNever()) // reserve slot; backfilled below
+
+	var out apiRetry.PolicyNode
+	switch n.kind {
+	case pkPeriodic:
+		if err := checkDur("Periodic delay", n.d1); err != nil {
+			return 0, err
+		}
+		out = apiRetry.MakePolicyNodePeriodic(ns(n.d1))
+	case pkExponential:
+		if err := checkDur("Exponential base", n.d1); err != nil {
+			return 0, err
+		}
+		if !finitePositive(n.factor) {
+			return 0, fmt.Errorf("Exponential factor must be finite and > 0, got %v", n.factor)
+		}
+		out = apiRetry.MakePolicyNodeExponential(apiRetry.ExponentialConfig{BaseDelay: ns(n.d1), Factor: n.factor})
+	case pkFibonacci:
+		if err := checkDur("Fibonacci first", n.d1); err != nil {
+			return 0, err
+		}
+		if err := checkDur("Fibonacci second", n.d2); err != nil {
+			return 0, err
+		}
+		out = apiRetry.MakePolicyNodeFibonacci(apiRetry.FibonacciConfig{First: ns(n.d1), Second: ns(n.d2)})
+	case pkImmediate:
+		out = apiRetry.MakePolicyNodeImmediate()
+	case pkNever:
+		out = apiRetry.MakePolicyNodeNever()
+	case pkCountBox:
+		inner, err := pushPolicy(n.inner, nodes)
+		if err != nil {
+			return 0, err
+		}
+		out = apiRetry.MakePolicyNodeCountBox(apiRetry.CountBoxConfig{MaxRetries: n.maxTries, Inner: inner})
+	case pkTimeBox:
+		if err := checkDur("Within budget", n.d1); err != nil {
+			return 0, err
+		}
+		inner, err := pushPolicy(n.inner, nodes)
+		if err != nil {
+			return 0, err
+		}
+		out = apiRetry.MakePolicyNodeTimeBox(apiRetry.TimeBoxConfig{Limit: ns(n.d1), Inner: inner})
+	case pkClampDelay:
+		if err := checkDur("Clamp min", n.d1); err != nil {
+			return 0, err
+		}
+		if err := checkDur("Clamp max", n.d2); err != nil {
+			return 0, err
+		}
+		if n.d1 > n.d2 {
+			return 0, fmt.Errorf("Clamp min (%v) must be <= max (%v)", n.d1, n.d2)
+		}
+		inner, err := pushPolicy(n.inner, nodes)
+		if err != nil {
+			return 0, err
+		}
+		out = apiRetry.MakePolicyNodeClampDelay(apiRetry.ClampConfig{MinDelay: ns(n.d1), MaxDelay: ns(n.d2), Inner: inner})
+	case pkAddDelay:
+		if err := checkDur("AddDelay", n.d1); err != nil {
+			return 0, err
+		}
+		inner, err := pushPolicy(n.inner, nodes)
+		if err != nil {
+			return 0, err
+		}
+		out = apiRetry.MakePolicyNodeAddDelay(apiRetry.AddDelayConfig{Delay: ns(n.d1), Inner: inner})
+	case pkJitter:
+		if !finiteNonNegative(n.factor) {
+			return 0, fmt.Errorf("WithJitter factor must be finite and >= 0, got %v", n.factor)
+		}
+		inner, err := pushPolicy(n.inner, nodes)
+		if err != nil {
+			return 0, err
+		}
+		out = apiRetry.MakePolicyNodeJitter(apiRetry.JitterConfig{Factor: n.factor, Inner: inner})
+	case pkFilteredOn:
+		pred, err := (Predicate{n.pred}).lower()
+		if err != nil {
+			return 0, err
+		}
+		inner, err := pushPolicy(n.inner, nodes)
+		if err != nil {
+			return 0, err
+		}
+		out = apiRetry.MakePolicyNodeFilteredOn(apiRetry.FilteredConfig{Predicate: pred, Inner: inner})
+	case pkAndThen, pkUnion, pkIntersect:
+		left, err := pushPolicy(n.left, nodes)
+		if err != nil {
+			return 0, err
+		}
+		right, err := pushPolicy(n.right, nodes)
+		if err != nil {
+			return 0, err
+		}
+		pair := witTypes.Tuple2[int32, int32]{F0: left, F1: right}
+		switch n.kind {
+		case pkAndThen:
+			out = apiRetry.MakePolicyNodeAndThen(pair)
+		case pkUnion:
+			out = apiRetry.MakePolicyNodePolicyUnion(pair)
+		default:
+			out = apiRetry.MakePolicyNodePolicyIntersect(pair)
+		}
+	default:
+		return 0, fmt.Errorf("internal: unknown policy kind %d", n.kind)
+	}
+
+	(*nodes)[idx] = out
+	return idx, nil
+}
+
+func (p Predicate) lower() (apiRetry.RetryPredicate, error) {
+	if p.node == nil {
+		return apiRetry.RetryPredicate{}, errors.New("invalid (zero) Predicate; build one from a retry property method or retry.MatchAlways")
+	}
+	var nodes []apiRetry.PredicateNode
+	if _, err := pushPredicate(p.node, &nodes); err != nil {
+		return apiRetry.RetryPredicate{}, err
+	}
+	return apiRetry.RetryPredicate{Nodes: nodes}, nil
+}
+
+func pushPredicate(n *predicateNode, nodes *[]apiRetry.PredicateNode) (int32, error) {
+	if n == nil {
+		return 0, errors.New("incomplete Predicate: a combinator was applied to a zero Predicate")
+	}
+	idx := int32(len(*nodes))
+	*nodes = append(*nodes, apiRetry.MakePredicateNodePredFalse()) // reserve slot
+
+	comparison := func() (apiRetry.PropertyComparison, error) {
+		pv, err := toPredicateValue(n.val)
+		return apiRetry.PropertyComparison{PropertyName: n.prop, Value: pv}, err
+	}
+
+	var out apiRetry.PredicateNode
+	switch n.kind {
+	case prEq, prNeq, prGt, prGte, prLt, prLte:
+		c, err := comparison()
+		if err != nil {
+			return 0, err
+		}
+		switch n.kind {
+		case prEq:
+			out = apiRetry.MakePredicateNodePropEq(c)
+		case prNeq:
+			out = apiRetry.MakePredicateNodePropNeq(c)
+		case prGt:
+			out = apiRetry.MakePredicateNodePropGt(c)
+		case prGte:
+			out = apiRetry.MakePredicateNodePropGte(c)
+		case prLt:
+			out = apiRetry.MakePredicateNodePropLt(c)
+		default:
+			out = apiRetry.MakePredicateNodePropLte(c)
+		}
+	case prExists:
+		out = apiRetry.MakePredicateNodePropExists(n.prop)
+	case prIn:
+		vals := make([]apiRetry.PredicateValue, 0, len(n.vals))
+		for _, v := range n.vals {
+			pv, err := toPredicateValue(v)
+			if err != nil {
+				return 0, err
+			}
+			vals = append(vals, pv)
+		}
+		out = apiRetry.MakePredicateNodePropIn(apiRetry.PropertySetCheck{PropertyName: n.prop, Values: vals})
+	case prMatches:
+		out = apiRetry.MakePredicateNodePropMatches(apiRetry.PropertyPattern{PropertyName: n.prop, Pattern: n.pat})
+	case prStartsWith:
+		out = apiRetry.MakePredicateNodePropStartsWith(apiRetry.PropertyPattern{PropertyName: n.prop, Pattern: n.pat})
+	case prContains:
+		out = apiRetry.MakePredicateNodePropContains(apiRetry.PropertyPattern{PropertyName: n.prop, Pattern: n.pat})
+	case prAnd, prOr:
+		left, err := pushPredicate(n.left, nodes)
+		if err != nil {
+			return 0, err
+		}
+		right, err := pushPredicate(n.right, nodes)
+		if err != nil {
+			return 0, err
+		}
+		pair := witTypes.Tuple2[int32, int32]{F0: left, F1: right}
+		if n.kind == prAnd {
+			out = apiRetry.MakePredicateNodePredAnd(pair)
+		} else {
+			out = apiRetry.MakePredicateNodePredOr(pair)
+		}
+	case prNot:
+		inner, err := pushPredicate(n.inner, nodes)
+		if err != nil {
+			return 0, err
+		}
+		out = apiRetry.MakePredicateNodePredNot(inner)
+	case prTrue:
+		out = apiRetry.MakePredicateNodePredTrue()
+	case prFalse:
+		out = apiRetry.MakePredicateNodePredFalse()
+	default:
+		return 0, fmt.Errorf("internal: unknown predicate kind %d", n.kind)
+	}
+
+	(*nodes)[idx] = out
+	return idx, nil
+}
+
+// ── Value coercion + range/finiteness checks ─────────────────────────────────
+
+func toPredicateValue(v any) (apiRetry.PredicateValue, error) {
+	switch x := v.(type) {
+	case string:
+		return apiRetry.MakePredicateValueText(x), nil
+	case bool:
+		return apiRetry.MakePredicateValueBoolean(x), nil
+	case int:
+		return apiRetry.MakePredicateValueInteger(int64(x)), nil
+	case int8:
+		return apiRetry.MakePredicateValueInteger(int64(x)), nil
+	case int16:
+		return apiRetry.MakePredicateValueInteger(int64(x)), nil
+	case int32:
+		return apiRetry.MakePredicateValueInteger(int64(x)), nil
+	case int64:
+		return apiRetry.MakePredicateValueInteger(x), nil
+	case uint8:
+		return apiRetry.MakePredicateValueInteger(int64(x)), nil
+	case uint16:
+		return apiRetry.MakePredicateValueInteger(int64(x)), nil
+	case uint32:
+		return apiRetry.MakePredicateValueInteger(int64(x)), nil
+	case uint:
+		if uint64(x) > math.MaxInt64 {
+			return apiRetry.PredicateValue{}, fmt.Errorf("predicate integer %d overflows int64", x)
+		}
+		return apiRetry.MakePredicateValueInteger(int64(x)), nil
+	case uint64:
+		if x > math.MaxInt64 {
+			return apiRetry.PredicateValue{}, fmt.Errorf("predicate integer %d overflows int64", x)
+		}
+		return apiRetry.MakePredicateValueInteger(int64(x)), nil
+	default:
+		return apiRetry.PredicateValue{}, fmt.Errorf("unsupported predicate value type %T (want string, an integer type, or bool)", v)
+	}
+}
+
+func checkDur(what string, d time.Duration) error {
+	if d < 0 {
+		return fmt.Errorf("%s must be non-negative, got %v", what, d)
+	}
+	return nil
+}
+
+func ns(d time.Duration) uint64 { return uint64(d.Nanoseconds()) }
+
+func finitePositive(f float64) bool {
+	return !math.IsNaN(f) && !math.IsInf(f, 0) && f > 0
+}
+
+func finiteNonNegative(f float64) bool {
+	return !math.IsNaN(f) && !math.IsInf(f, 0) && f >= 0
+}
+
+// ── Decoding (host graph -> value tree); guarded against malformed input ──────
+
+func decodeNamed(raw apiRetry.NamedRetryPolicy) (NamedPolicy, error) {
+	pol, err := decodePolicy(raw.Policy)
+	if err != nil {
+		return NamedPolicy{}, err
+	}
+	pred, err := decodePredicate(raw.Predicate)
+	if err != nil {
+		return NamedPolicy{}, err
+	}
+	return NamedPolicy{name: raw.Name, priority: raw.Priority, applies: pred, policy: pol}, nil
+}
+
+func decodePolicy(raw apiRetry.RetryPolicy) (Policy, error) {
+	node, err := decodePolicyNode(raw.Nodes, 0, map[int32]bool{})
+	if err != nil {
+		return Policy{}, err
+	}
+	return Policy{node}, nil
+}
+
+func decodePolicyNode(nodes []apiRetry.PolicyNode, idx int32, path map[int32]bool) (*policyNode, error) {
+	if len(nodes) == 0 {
+		return nil, errors.New("golem/retry: empty policy node list")
+	}
+	if idx < 0 || int(idx) >= len(nodes) {
+		return nil, fmt.Errorf("golem/retry: policy node index %d out of range [0,%d)", idx, len(nodes))
+	}
+	if path[idx] {
+		return nil, fmt.Errorf("golem/retry: cycle in policy graph at node %d", idx)
+	}
+	path[idx] = true
+	defer delete(path, idx)
+
+	w := nodes[idx]
+	switch w.Tag() {
+	case apiRetry.PolicyNodePeriodic:
+		return &policyNode{kind: pkPeriodic, d1: durOf(w.Periodic())}, nil
+	case apiRetry.PolicyNodeExponential:
+		c := w.Exponential()
+		return &policyNode{kind: pkExponential, d1: durOf(c.BaseDelay), factor: c.Factor}, nil
+	case apiRetry.PolicyNodeFibonacci:
+		c := w.Fibonacci()
+		return &policyNode{kind: pkFibonacci, d1: durOf(c.First), d2: durOf(c.Second)}, nil
+	case apiRetry.PolicyNodeImmediate:
+		return &policyNode{kind: pkImmediate}, nil
+	case apiRetry.PolicyNodeNever:
+		return &policyNode{kind: pkNever}, nil
+	case apiRetry.PolicyNodeCountBox:
+		c := w.CountBox()
+		inner, err := decodePolicyNode(nodes, c.Inner, path)
+		if err != nil {
+			return nil, err
+		}
+		return &policyNode{kind: pkCountBox, maxTries: c.MaxRetries, inner: inner}, nil
+	case apiRetry.PolicyNodeTimeBox:
+		c := w.TimeBox()
+		inner, err := decodePolicyNode(nodes, c.Inner, path)
+		if err != nil {
+			return nil, err
+		}
+		return &policyNode{kind: pkTimeBox, d1: durOf(c.Limit), inner: inner}, nil
+	case apiRetry.PolicyNodeClampDelay:
+		c := w.ClampDelay()
+		inner, err := decodePolicyNode(nodes, c.Inner, path)
+		if err != nil {
+			return nil, err
+		}
+		return &policyNode{kind: pkClampDelay, d1: durOf(c.MinDelay), d2: durOf(c.MaxDelay), inner: inner}, nil
+	case apiRetry.PolicyNodeAddDelay:
+		c := w.AddDelay()
+		inner, err := decodePolicyNode(nodes, c.Inner, path)
+		if err != nil {
+			return nil, err
+		}
+		return &policyNode{kind: pkAddDelay, d1: durOf(c.Delay), inner: inner}, nil
+	case apiRetry.PolicyNodeJitter:
+		c := w.Jitter()
+		inner, err := decodePolicyNode(nodes, c.Inner, path)
+		if err != nil {
+			return nil, err
+		}
+		return &policyNode{kind: pkJitter, factor: c.Factor, inner: inner}, nil
+	case apiRetry.PolicyNodeFilteredOn:
+		c := w.FilteredOn()
+		pred, err := decodePredicate(c.Predicate)
+		if err != nil {
+			return nil, err
+		}
+		inner, err := decodePolicyNode(nodes, c.Inner, path)
+		if err != nil {
+			return nil, err
+		}
+		return &policyNode{kind: pkFilteredOn, pred: pred.node, inner: inner}, nil
+	case apiRetry.PolicyNodeAndThen, apiRetry.PolicyNodePolicyUnion, apiRetry.PolicyNodePolicyIntersect:
+		var pair witTypes.Tuple2[int32, int32]
+		var kind policyKind
+		switch w.Tag() {
+		case apiRetry.PolicyNodeAndThen:
+			pair, kind = w.AndThen(), pkAndThen
+		case apiRetry.PolicyNodePolicyUnion:
+			pair, kind = w.PolicyUnion(), pkUnion
+		default:
+			pair, kind = w.PolicyIntersect(), pkIntersect
+		}
+		left, err := decodePolicyNode(nodes, pair.F0, path)
+		if err != nil {
+			return nil, err
+		}
+		right, err := decodePolicyNode(nodes, pair.F1, path)
+		if err != nil {
+			return nil, err
+		}
+		return &policyNode{kind: kind, left: left, right: right}, nil
+	default:
+		return nil, fmt.Errorf("golem/retry: unknown policy node tag %d", w.Tag())
+	}
+}
+
+func decodePredicate(raw apiRetry.RetryPredicate) (Predicate, error) {
+	node, err := decodePredicateNode(raw.Nodes, 0, map[int32]bool{})
+	if err != nil {
+		return Predicate{}, err
+	}
+	return Predicate{node}, nil
+}
+
+func decodePredicateNode(nodes []apiRetry.PredicateNode, idx int32, path map[int32]bool) (*predicateNode, error) {
+	if len(nodes) == 0 {
+		return nil, errors.New("golem/retry: empty predicate node list")
+	}
+	if idx < 0 || int(idx) >= len(nodes) {
+		return nil, fmt.Errorf("golem/retry: predicate node index %d out of range [0,%d)", idx, len(nodes))
+	}
+	if path[idx] {
+		return nil, fmt.Errorf("golem/retry: cycle in predicate graph at node %d", idx)
+	}
+	path[idx] = true
+	defer delete(path, idx)
+
+	w := nodes[idx]
+	cmp := func(kind predKind, c apiRetry.PropertyComparison) (*predicateNode, error) {
+		return &predicateNode{kind: kind, prop: c.PropertyName, val: fromPredicateValue(c.Value)}, nil
+	}
+	switch w.Tag() {
+	case apiRetry.PredicateNodePropEq:
+		return cmp(prEq, w.PropEq())
+	case apiRetry.PredicateNodePropNeq:
+		return cmp(prNeq, w.PropNeq())
+	case apiRetry.PredicateNodePropGt:
+		return cmp(prGt, w.PropGt())
+	case apiRetry.PredicateNodePropGte:
+		return cmp(prGte, w.PropGte())
+	case apiRetry.PredicateNodePropLt:
+		return cmp(prLt, w.PropLt())
+	case apiRetry.PredicateNodePropLte:
+		return cmp(prLte, w.PropLte())
+	case apiRetry.PredicateNodePropExists:
+		return &predicateNode{kind: prExists, prop: w.PropExists()}, nil
+	case apiRetry.PredicateNodePropIn:
+		c := w.PropIn()
+		vals := make([]any, 0, len(c.Values))
+		for _, pv := range c.Values {
+			vals = append(vals, fromPredicateValue(pv))
+		}
+		return &predicateNode{kind: prIn, prop: c.PropertyName, vals: vals}, nil
+	case apiRetry.PredicateNodePropMatches:
+		c := w.PropMatches()
+		return &predicateNode{kind: prMatches, prop: c.PropertyName, pat: c.Pattern}, nil
+	case apiRetry.PredicateNodePropStartsWith:
+		c := w.PropStartsWith()
+		return &predicateNode{kind: prStartsWith, prop: c.PropertyName, pat: c.Pattern}, nil
+	case apiRetry.PredicateNodePropContains:
+		c := w.PropContains()
+		return &predicateNode{kind: prContains, prop: c.PropertyName, pat: c.Pattern}, nil
+	case apiRetry.PredicateNodePredAnd, apiRetry.PredicateNodePredOr:
+		var pair witTypes.Tuple2[int32, int32]
+		var kind predKind
+		if w.Tag() == apiRetry.PredicateNodePredAnd {
+			pair, kind = w.PredAnd(), prAnd
+		} else {
+			pair, kind = w.PredOr(), prOr
+		}
+		left, err := decodePredicateNode(nodes, pair.F0, path)
+		if err != nil {
+			return nil, err
+		}
+		right, err := decodePredicateNode(nodes, pair.F1, path)
+		if err != nil {
+			return nil, err
+		}
+		return &predicateNode{kind: kind, left: left, right: right}, nil
+	case apiRetry.PredicateNodePredNot:
+		inner, err := decodePredicateNode(nodes, w.PredNot(), path)
+		if err != nil {
+			return nil, err
+		}
+		return &predicateNode{kind: prNot, inner: inner}, nil
+	case apiRetry.PredicateNodePredTrue:
+		return &predicateNode{kind: prTrue}, nil
+	case apiRetry.PredicateNodePredFalse:
+		return &predicateNode{kind: prFalse}, nil
+	default:
+		return nil, fmt.Errorf("golem/retry: unknown predicate node tag %d", w.Tag())
+	}
+}
+
+func fromPredicateValue(pv apiRetry.PredicateValue) any {
+	switch pv.Tag() {
+	case apiRetry.PredicateValueText:
+		return pv.Text()
+	case apiRetry.PredicateValueInteger:
+		return pv.Integer()
+	default:
+		return pv.Boolean()
+	}
+}
+
+func durOf(nanos uint64) time.Duration { return time.Duration(nanos) }
diff --git a/sdks/go/golem/retry/retry_test.go b/sdks/go/golem/retry/retry_test.go
new file mode 100644
index 0000000000..be9a19289c
--- /dev/null
+++ b/sdks/go/golem/retry/retry_test.go
@@ -0,0 +1,222 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 retry
+
+import (
+	"math"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	apiRetry "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_retry"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// TestPolicyLoweringStructure — a nested policy lowers to the expected flattened
+// node array with root at index 0 and correct child indices (mirrors the Rust
+// reference test): CountBox(0) -> FilteredOn(1) -> ClampDelay(2) -> Exponential(3).
+func TestPolicyLoweringStructure(t *testing.T) {
+	pol := Exponential(200*time.Millisecond, 2.0).
+		Clamp(100*time.Millisecond, 5*time.Second).
+		OnlyWhen(StatusCode.OneOf(502, 503, 504)).
+		MaxRetries(3)
+
+	raw, err := pol.lower()
+	if err != nil {
+		t.Fatalf("lower: %v", err)
+	}
+	if len(raw.Nodes) != 4 {
+		t.Fatalf("nodes len = %d, want 4", len(raw.Nodes))
+	}
+	if raw.Nodes[0].Tag() != apiRetry.PolicyNodeCountBox {
+		t.Fatalf("nodes[0] tag = %d, want CountBox", raw.Nodes[0].Tag())
+	}
+	if cb := raw.Nodes[0].CountBox(); cb.MaxRetries != 3 || cb.Inner != 1 {
+		t.Fatalf("nodes[0] = %+v, want {MaxRetries:3 Inner:1}", cb)
+	}
+	if raw.Nodes[1].Tag() != apiRetry.PolicyNodeFilteredOn || raw.Nodes[1].FilteredOn().Inner != 2 {
+		t.Fatalf("nodes[1] = %+v, want FilteredOn{Inner:2}", raw.Nodes[1])
+	}
+	if raw.Nodes[2].Tag() != apiRetry.PolicyNodeClampDelay {
+		t.Fatalf("nodes[2] tag = %d, want ClampDelay", raw.Nodes[2].Tag())
+	}
+	if cl := raw.Nodes[2].ClampDelay(); cl.Inner != 3 || cl.MinDelay != uint64(100*time.Millisecond) || cl.MaxDelay != uint64(5*time.Second) {
+		t.Fatalf("nodes[2] = %+v", cl)
+	}
+	if raw.Nodes[3].Tag() != apiRetry.PolicyNodeExponential {
+		t.Fatalf("nodes[3] tag = %d, want Exponential", raw.Nodes[3].Tag())
+	}
+	if e := raw.Nodes[3].Exponential(); e.BaseDelay != uint64(200*time.Millisecond) || e.Factor != 2.0 {
+		t.Fatalf("nodes[3] = %+v", e)
+	}
+
+	// The embedded predicate (from OnlyWhen) is a self-contained PropIn.
+	pred := raw.Nodes[1].FilteredOn().Predicate
+	if len(pred.Nodes) != 1 || pred.Nodes[0].Tag() != apiRetry.PredicateNodePropIn {
+		t.Fatalf("embedded predicate = %+v, want single PropIn", pred.Nodes)
+	}
+	if in := pred.Nodes[0].PropIn(); in.PropertyName != "status-code" || len(in.Values) != 3 {
+		t.Fatalf("PropIn = %+v", in)
+	}
+}
+
+// TestPredicateLoweringStructure — And lowers to a combinator at root referencing
+// its two operands by index.
+func TestPredicateLoweringStructure(t *testing.T) {
+	pred := Verb.Eq("GET").And(StatusCode.Gte(500))
+	raw, err := pred.lower()
+	if err != nil {
+		t.Fatalf("lower: %v", err)
+	}
+	if len(raw.Nodes) != 3 {
+		t.Fatalf("nodes len = %d, want 3", len(raw.Nodes))
+	}
+	if raw.Nodes[0].Tag() != apiRetry.PredicateNodePredAnd {
+		t.Fatalf("nodes[0] tag = %d, want PredAnd", raw.Nodes[0].Tag())
+	}
+	if a := raw.Nodes[0].PredAnd(); a.F0 != 1 || a.F1 != 2 {
+		t.Fatalf("PredAnd = %+v, want {1,2}", a)
+	}
+	if raw.Nodes[1].Tag() != apiRetry.PredicateNodePropEq || raw.Nodes[1].PropEq().PropertyName != "verb" {
+		t.Fatalf("nodes[1] = %+v", raw.Nodes[1])
+	}
+	if raw.Nodes[2].Tag() != apiRetry.PredicateNodePropGte {
+		t.Fatalf("nodes[2] tag = %d, want PropGte", raw.Nodes[2].Tag())
+	}
+	if v := raw.Nodes[1].PropEq().Value; v.Tag() != apiRetry.PredicateValueText || v.Text() != "GET" {
+		t.Fatalf("verb value = %+v", v)
+	}
+	if v := raw.Nodes[2].PropGte().Value; v.Tag() != apiRetry.PredicateValueInteger || v.Integer() != 500 {
+		t.Fatalf("status value = %+v", v)
+	}
+}
+
+// TestNamedDefaults — Named defaults to priority 0 and an always-applies predicate.
+func TestNamedDefaults(t *testing.T) {
+	raw, err := Named("p", Immediate()).lower()
+	if err != nil {
+		t.Fatalf("lower: %v", err)
+	}
+	if raw.Name != "p" || raw.Priority != 0 {
+		t.Fatalf("name/priority = %q/%d", raw.Name, raw.Priority)
+	}
+	if len(raw.Predicate.Nodes) != 1 || raw.Predicate.Nodes[0].Tag() != apiRetry.PredicateNodePredTrue {
+		t.Fatalf("default predicate = %+v, want single PredTrue", raw.Predicate.Nodes)
+	}
+}
+
+func TestValidationErrors(t *testing.T) {
+	cases := []struct {
+		name string
+		np   NamedPolicy
+		want string
+	}{
+		{"zero policy", Named("x", Policy{}), "zero) Policy"},
+		{"exponential factor 0", Named("x", Exponential(time.Second, 0)), "factor must be finite and > 0"},
+		{"exponential factor inf", Named("x", Exponential(time.Second, math.Inf(1))), "factor must be finite"},
+		{"jitter negative", Named("x", Immediate().WithJitter(-1)), "factor must be finite and >= 0"},
+		{"clamp min>max", Named("x", Immediate().Clamp(2*time.Second, time.Second)), "must be <= max"},
+		{"negative duration", Named("x", Periodic(-time.Second)), "must be non-negative"},
+		{"bad predicate value", Named("x", Immediate().OnlyWhen(StatusCode.Eq(1.5))), "unsupported predicate value type"},
+		{"integer overflow", Named("x", Immediate().OnlyWhen(StatusCode.Eq(uint64(math.MaxInt64) + 1))), "overflows int64"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			err := c.np.Validate()
+			if err == nil {
+				t.Fatalf("expected error containing %q, got nil", c.want)
+			}
+			if !strings.Contains(err.Error(), c.want) {
+				t.Fatalf("error %q does not contain %q", err.Error(), c.want)
+			}
+		})
+	}
+}
+
+// TestValidPolicyValidates — a well-formed policy passes Validate.
+func TestValidPolicyValidates(t *testing.T) {
+	np := Named("ok", Exponential(time.Second, 2).WithJitter(0.5).MaxRetries(5)).
+		WithPriority(7).
+		AppliesWhen(Verb.Eq("GET").Or(Verb.Eq("HEAD")))
+	if err := np.Validate(); err != nil {
+		t.Fatalf("Validate: %v", err)
+	}
+}
+
+// TestRoundTrip — lower -> decode -> lower yields an identical node graph, for
+// both the policy and its embedded/applicability predicates.
+func TestRoundTrip(t *testing.T) {
+	np := Named("rt", Exponential(200*time.Millisecond, 2).
+		Clamp(0, time.Second).
+		AddDelay(50*time.Millisecond).
+		OnlyWhen(ErrorType.Contains("timeout")).
+		MaxRetries(3).
+		AndThen(Periodic(time.Second).Within(time.Minute))).
+		WithPriority(9).
+		AppliesWhen(StatusCode.Gte(500).And(URIHost.MatchesGlob("*.example.com")).Not())
+
+	raw1, err := np.lower()
+	if err != nil {
+		t.Fatalf("lower1: %v", err)
+	}
+	decoded, err := decodeNamed(raw1)
+	if err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	raw2, err := decoded.lower()
+	if err != nil {
+		t.Fatalf("lower2: %v", err)
+	}
+	if !reflect.DeepEqual(raw1.Policy.Nodes, raw2.Policy.Nodes) {
+		t.Fatalf("policy round-trip mismatch:\n %+v\n %+v", raw1.Policy.Nodes, raw2.Policy.Nodes)
+	}
+	if !reflect.DeepEqual(raw1.Predicate.Nodes, raw2.Predicate.Nodes) {
+		t.Fatalf("predicate round-trip mismatch:\n %+v\n %+v", raw1.Predicate.Nodes, raw2.Predicate.Nodes)
+	}
+	if raw2.Name != "rt" || raw2.Priority != 9 {
+		t.Fatalf("named fields lost: %q/%d", raw2.Name, raw2.Priority)
+	}
+}
+
+func TestDecodeGuards(t *testing.T) {
+	// empty node list
+	if _, err := decodePolicy(apiRetry.RetryPolicy{}); err == nil || !strings.Contains(err.Error(), "empty policy node list") {
+		t.Fatalf("empty: %v", err)
+	}
+	// dangling index: single CountBox pointing at index 5
+	dangling := apiRetry.RetryPolicy{Nodes: []apiRetry.PolicyNode{
+		apiRetry.MakePolicyNodeCountBox(apiRetry.CountBoxConfig{MaxRetries: 1, Inner: 5}),
+	}}
+	if _, err := decodePolicy(dangling); err == nil || !strings.Contains(err.Error(), "out of range") {
+		t.Fatalf("dangling: %v", err)
+	}
+	// cycle: node0 -> node1 -> node0
+	cyclic := apiRetry.RetryPolicy{Nodes: []apiRetry.PolicyNode{
+		apiRetry.MakePolicyNodeCountBox(apiRetry.CountBoxConfig{MaxRetries: 1, Inner: 1}),
+		apiRetry.MakePolicyNodeCountBox(apiRetry.CountBoxConfig{MaxRetries: 1, Inner: 0}),
+	}}
+	if _, err := decodePolicy(cyclic); err == nil || !strings.Contains(err.Error(), "cycle") {
+		t.Fatalf("cycle: %v", err)
+	}
+	// predicate combinator with a dangling operand
+	badPred := apiRetry.RetryPredicate{Nodes: []apiRetry.PredicateNode{
+		apiRetry.MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{F0: 1, F1: 9}),
+		apiRetry.MakePredicateNodePredTrue(),
+	}}
+	if _, err := decodePredicate(badPred); err == nil || !strings.Contains(err.Error(), "out of range") {
+		t.Fatalf("bad predicate: %v", err)
+	}
+}
diff --git a/sdks/go/golem/rpc.go b/sdks/go/golem/rpc.go
new file mode 100644
index 0000000000..b6f3972143
--- /dev/null
+++ b/sdks/go/golem/rpc.go
@@ -0,0 +1,289 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"fmt"
+	"reflect"
+	"time"
+
+	host "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_host"
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	clock "github.com/golemcloud/golem/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_system_clock"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// Cross-agent calls hang off the method descriptor rather than the client:
+//
+//	res := Charge.Call(pay, ChargeIn{AmountCents: 500})
+//
+// Go methods cannot introduce type parameters, so a Client[Id] could never have
+// a Call[In, Out] method. The descriptor already binds In and Out, and shares Id
+// with the client — which is what makes aiming a method at the wrong agent a
+// compile error.
+//
+// The RPC methods are FAIL-LOUD: they return the value and panic on an infra
+// failure (a [RemoteCallError] — the callee failed, or was unreachable after the
+// runtime exhausted its retries). This matches Golem's exactly-once model — the
+// runtime handles transient failures and replays deterministically, so a failure
+// that reaches the guest is terminal; the documented way to "rely on" the
+// automatic retry is to let it propagate. Model *expected* outcomes as a [Result]
+// in the method's output instead. To degrade gracefully on a non-critical call
+// (rare), wrap it and recover the [RemoteCallError].
+
+// Call invokes the method and waits for its result, panicking on an infra failure.
+//
+// This maps to the synchronous `invoke-and-await` import, so it blocks the whole
+// component until the remote returns. To have several calls in flight at once,
+// use [MethodDef.CallAsync].
+func (m MethodDef[Id, In, Out]) Call(c Client[Id], in In) Out {
+	if c.rpc == nil {
+		panic(fmt.Errorf("golem: %s: called on a zero Client", m.name))
+	}
+	tree, err := m.encodeInput(in)
+	if err != nil {
+		panic(err)
+	}
+	res := c.rpc.InvokeAndAwait(m.name, tree)
+	if res.IsErr() {
+		panic(rpcErrorToGo(c.agentID, m.name, res.Err()))
+	}
+	out, err := decodeOutput[Out](c.agentID, m.name, res.Ok().Result)
+	if err != nil {
+		panic(err)
+	}
+	return out
+}
+
+// Trigger invokes the method without waiting for a result, returning the
+// invocation's identity (panicking on an infra failure). Failures after the
+// invocation is accepted are not reported here.
+func (m MethodDef[Id, In, Out]) Trigger(c Client[Id], in In) InvocationID {
+	if c.rpc == nil {
+		panic(fmt.Errorf("golem: %s: called on a zero Client", m.name))
+	}
+	tree, err := m.encodeInput(in)
+	if err != nil {
+		panic(err)
+	}
+	res := c.rpc.Invoke(m.name, tree)
+	if res.IsErr() {
+		panic(rpcErrorToGo(c.agentID, m.name, res.Err()))
+	}
+	return invocationIDFrom(res.Ok())
+}
+
+// Schedule arranges for the method to be invoked at the given time and returns a
+// token that can cancel it beforehand (panicking on an infra failure).
+func (m MethodDef[Id, In, Out]) Schedule(c Client[Id], at time.Time, in In) *ScheduledInvocation {
+	if c.rpc == nil {
+		panic(fmt.Errorf("golem: %s: called on a zero Client", m.name))
+	}
+	tree, err := m.encodeInput(in)
+	if err != nil {
+		panic(err)
+	}
+	receipt := c.rpc.ScheduleCancelableInvocation(instantFrom(at), m.name, tree)
+	return &ScheduledInvocation{
+		ID:    invocationIDFrom(receipt.Metadata),
+		token: receipt.CancellationToken,
+	}
+}
+
+// CallAsync starts the invocation and returns immediately with a future
+// (panicking on an infra failure at start).
+//
+// This is the only way to have several invocations in flight: `invoke-and-await`
+// is a synchronous import and blocks the component, whereas the future's Get is
+// async, so a goroutine blocked in it yields to the component-model event loop
+// and lets other goroutines proceed.
+//
+// Note the platform contract: a single target instance handles one invocation at
+// a time, so fanning out to the SAME agent instance does not run in parallel.
+// Concurrency is across DIFFERENT targets.
+func (m MethodDef[Id, In, Out]) CallAsync(c Client[Id], in In) *Future[Out] {
+	if c.rpc == nil {
+		panic(fmt.Errorf("golem: %s: called on a zero Client", m.name))
+	}
+	tree, err := m.encodeInput(in)
+	if err != nil {
+		panic(err)
+	}
+	inv := c.rpc.AsyncInvokeAndAwait(m.name, tree)
+	return &Future[Out]{
+		ID:     invocationIDFrom(inv.Metadata),
+		fut:    inv.Future,
+		method: m.name,
+		target: c.agentID,
+	}
+}
+
+// ---------------------------------------------------------------------------
+// encoding / decoding, shared by every call shape
+// ---------------------------------------------------------------------------
+
+// encodeInput encodes the In value into a parameter-list value tree. The callee
+// derives the same field list from the same Go type, which is what keeps the two
+// sides symmetric.
+func (m MethodDef[Id, In, Out]) encodeInput(in In) (tree types.SchemaValueTree, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			err = fmt.Errorf("golem: %s: encoding input: %v", m.name, r)
+		}
+	}()
+	inType := reflect.TypeFor[In]()
+	return encodeParams(defs.structFields(inType), reflect.ValueOf(&in).Elem()), nil
+}
+
+// decodeOutput decodes a remote result through the LOCAL descriptor's Out codec.
+// That codec checks every node tag, so a remote returning the wrong shape yields
+// an error rather than a panic.
+func decodeOutput[Out any](target, method string, out witTypes.Option[types.SchemaValueTree]) (Out, error) {
+	var zero Out
+	outType := reflect.TypeFor[Out]()
+	if outType == reflect.TypeFor[Unit]() {
+		return zero, nil
+	}
+	if out.IsNone() {
+		return zero, &RemoteCallError{
+			Target: target, Method: method, Kind: RemoteProtocol,
+			Message: "remote returned no value for a non-unit output",
+		}
+	}
+	tree := out.Some()
+	dst := reflect.New(outType).Elem()
+	dec := decoder{nodes: tree.ValueNodes}
+	if err := defs.compile(outType).decode(&dec, dst, tree.Root); err != nil {
+		return zero, &RemoteCallError{
+			Target: target, Method: method, Kind: RemoteProtocol,
+			Message: "remote returned an undecodable value: " + err.Error(),
+		}
+	}
+	return dst.Interface().(Out), nil
+}
+
+// ---------------------------------------------------------------------------
+// invocation identity and scheduling
+// ---------------------------------------------------------------------------
+
+// InvocationID identifies one remote invocation.
+type InvocationID struct {
+	AgentID        string
+	IdempotencyKey string
+}
+
+func invocationIDFrom(m host.InvocationMetadata) InvocationID {
+	return InvocationID{AgentID: m.AgentId, IdempotencyKey: m.IdempotencyKey}
+}
+
+// ScheduledInvocation is a future invocation that has not run yet.
+type ScheduledInvocation struct {
+	ID    InvocationID
+	token *host.CancellationToken
+}
+
+// Cancel prevents the invocation, if it has not already started.
+func (s *ScheduledInvocation) Cancel() {
+	if s.token != nil {
+		s.token.Cancel()
+		s.token = nil
+	}
+}
+
+func instantFrom(t time.Time) clock.Instant {
+	return clock.Instant{
+		Seconds:     t.Unix(),
+		Nanoseconds: uint32(t.Nanosecond()),
+	}
+}
+
+// ---------------------------------------------------------------------------
+// errors
+// ---------------------------------------------------------------------------
+
+// RemoteErrorKind classifies an RPC failure, mirroring the WIT rpc-error cases.
+type RemoteErrorKind uint8
+
+const (
+	// RemoteProtocol is a transport or encoding level failure.
+	RemoteProtocol RemoteErrorKind = iota
+	// RemoteDenied means the caller is not permitted to make this call.
+	RemoteDenied
+	// RemoteNotFound means the target agent or method does not exist.
+	RemoteNotFound
+	// RemoteInternal is an unexpected failure on the remote side.
+	RemoteInternal
+	// RemoteAgent means the remote returned a domain error; see Cause.
+	RemoteAgent
+)
+
+func (k RemoteErrorKind) String() string {
+	switch k {
+	case RemoteDenied:
+		return "denied"
+	case RemoteNotFound:
+		return "not found"
+	case RemoteInternal:
+		return "remote internal error"
+	case RemoteAgent:
+		return "remote agent error"
+	default:
+		return "protocol error"
+	}
+}
+
+// RemoteCallError is returned by every cross-agent call that fails.
+//
+// A remote domain error keeps its Cause rather than being flattened into a
+// string, so a remote custom-error stays inspectable by the caller.
+type RemoteCallError struct {
+	Target  string
+	Method  string
+	Kind    RemoteErrorKind
+	Message string
+	Cause   error
+}
+
+func (e *RemoteCallError) Error() string {
+	target := e.Target
+	if target == "" {
+		target = "<unknown agent>"
+	}
+	return fmt.Sprintf("golem: calling %s.%s: %s: %s", target, e.Method, e.Kind, e.Message)
+}
+
+func (e *RemoteCallError) Unwrap() error { return e.Cause }
+
+func rpcErrorToGo(target, method string, e host.RpcError) error {
+	err := &RemoteCallError{Target: target, Method: method}
+	switch e.Tag() {
+	case host.RpcErrorProtocolError:
+		err.Kind, err.Message = RemoteProtocol, e.ProtocolError()
+	case host.RpcErrorDenied:
+		err.Kind, err.Message = RemoteDenied, e.Denied()
+	case host.RpcErrorNotFound:
+		err.Kind, err.Message = RemoteNotFound, e.NotFound()
+	case host.RpcErrorRemoteInternalError:
+		err.Kind, err.Message = RemoteInternal, e.RemoteInternalError()
+	case host.RpcErrorRemoteAgentError:
+		remote := e.RemoteAgentError()
+		err.Kind = RemoteAgent
+		err.Cause = agentErrorToGo(remote)
+		err.Message = err.Cause.Error()
+	default:
+		err.Kind, err.Message = RemoteProtocol, fmt.Sprintf("unknown rpc-error (tag %d)", e.Tag())
+	}
+	return err
+}
diff --git a/sdks/go/golem/rpc_test.go b/sdks/go/golem/rpc_test.go
new file mode 100644
index 0000000000..936c47e3a6
--- /dev/null
+++ b/sdks/go/golem/rpc_test.go
@@ -0,0 +1,235 @@
+package golem
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+	host "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_host"
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// The Go SDK's tests are layered (see the go-sdk-testing-strategy notes):
+//
+//   - Pure logic is unit-tested here, natively, under `go test`: argument
+//     encoding, result decoding, error mapping, and the small value projections.
+//     None of these functions reference a `//go:wasmimport` symbol, so they link
+//     and run on the host. We push as much logic as possible into this layer.
+//   - The wasi-touching wrappers — Call, Trigger, Schedule, CallAsync,
+//     Future.Get/Cancel, ClientFor — cannot run natively: calling one references
+//     a wasmimport symbol the host linker can't resolve (`empty.s` lets the
+//     generated package compile, but not link a referenced import). These are
+//     covered by the CLI-driven and runtime (worker-executor) integration layers
+//     instead, which build the component to wasm and run it.
+
+type tPayId struct{ Merchant string }
+type tPayState struct{ charged int64 }
+type tChargeIn struct {
+	AmountCents int64
+	Note        *string
+}
+
+var tPayment = DefineAgent[tPayId, tPayState](
+	Spec{Name: "TestPayment", Mode: Durable},
+	func(id tPayId) *tPayState { return &tPayState{} },
+)
+
+var tCharge = DefineMethod[tPayId, tChargeIn, Money]("charge")
+
+func init() {
+	Implement(tPayment, tCharge, func(ctx *Context[tPayState], in tChargeIn) Money {
+		ctx.State.charged += in.AmountCents
+		return Money{Amount: ctx.State.charged, Currency: "EUR"}
+	})
+}
+
+// TestCallerEncodingMatchesCalleeDecoding — The caller encodes arguments with the same codecs the callee decodes with,
+// because both are derived from the same Go types. This is the symmetry claim
+// the design rests on, and it is checkable without a host.
+func TestCallerEncodingMatchesCalleeDecoding(t *testing.T) {
+	note := "tip"
+	in := tChargeIn{AmountCents: 1250, Note: &note}
+
+	tree, err := tCharge.encodeInput(in)
+	if err != nil {
+		t.Fatalf("encodeInput: %v", err)
+	}
+
+	// Decode it the way the callee's invoke path does.
+	fields := defs.structFields(reflect.TypeFor[tChargeIn]())
+	dst := reflect.New(reflect.TypeFor[tChargeIn]()).Elem()
+	if err := decodeParams(tree, fields, dst); err != nil {
+		t.Fatalf("callee could not decode the caller's arguments: %v", err)
+	}
+	if got := dst.Interface().(tChargeIn); !reflect.DeepEqual(got, in) {
+		t.Fatalf("round trip changed the arguments\n got: %#v\nwant: %#v", got, in)
+	}
+}
+
+// TestCallArgumentsAgreeWithThePublishedSchema — The encoded argument list must agree with the schema the callee publishes.
+func TestCallArgumentsAgreeWithThePublishedSchema(t *testing.T) {
+	tree, err := tCharge.encodeInput(tChargeIn{AmountCents: 7})
+	if err != nil {
+		t.Fatalf("encodeInput: %v", err)
+	}
+	at, _ := defs.buildAgentType(defs.agents["TestPayment"])
+
+	var charge *common.AgentMethod
+	for i := range at.Methods {
+		if at.Methods[i].Name == "charge" {
+			charge = &at.Methods[i]
+		}
+	}
+	if charge == nil {
+		t.Fatal("charge missing from the published agent type")
+	}
+
+	params := charge.InputSchema.Parameters()
+	root := tree.ValueNodes[tree.Root]
+	if root.Tag() != types.SchemaValueNodeRecordValue {
+		t.Fatalf("argument list root tag = %d, want record", root.Tag())
+	}
+	idxs := root.RecordValue()
+	if len(idxs) != len(params) {
+		t.Fatalf("encoded %d argument(s), schema declares %d", len(idxs), len(params))
+	}
+	// Each argument must match its declared parameter type.
+	for i, p := range params {
+		checkAgreement2(t, at.Schema, p.Schema, tree, idxs[i], p.Name)
+	}
+}
+
+// checkAgreement2 adapts the Phase 3 helper, which returns an error.
+func checkAgreement2(t *testing.T, g types.SchemaGraph, s int32, tree types.SchemaValueTree, v int32, path string) {
+	t.Helper()
+	if err := checkAgreement(g, s, tree, v, path); err != nil {
+		t.Fatalf("argument %q disagrees with its declared type: %v", path, err)
+	}
+}
+
+// TestClientConstructorTreeMatchesTheTargetConstructor — The constructor tree a client builds must be decodable as the target's
+// constructor parameters — otherwise the agent id would address nothing.
+func TestClientConstructorTreeMatchesTheTargetConstructor(t *testing.T) {
+	e := defs.agents["TestPayment"]
+	id := tPayId{Merchant: "acme"}
+	ctor := encodeParams(e.idFields, reflect.ValueOf(&id).Elem())
+
+	dst := reflect.New(reflect.TypeFor[tPayId]()).Elem()
+	if err := decodeParams(ctor, e.idFields, dst); err != nil {
+		t.Fatalf("target cannot decode the client's constructor tree: %v", err)
+	}
+	if got := dst.Interface().(tPayId); got != id {
+		t.Fatalf("constructor round trip = %#v, want %#v", got, id)
+	}
+}
+
+func TestDecodeOutputRejectsAMismatchedRemote(t *testing.T) {
+	// A remote claiming to return Money but sending a bare string.
+	bad := types.SchemaValueTree{
+		ValueNodes: []types.SchemaValueNode{types.MakeSchemaValueNodeStringValue("nope")},
+		Root:       0,
+	}
+	_, err := decodeOutput[Money]("agent-1", "charge", witTypes.Some(bad))
+	if err == nil {
+		t.Fatal("expected an error decoding a string as Money")
+	}
+	var rce *RemoteCallError
+	if !errors.As(err, &rce) {
+		t.Fatalf("expected a *RemoteCallError, got %T", err)
+	}
+	if rce.Kind != RemoteProtocol || rce.Method != "charge" || rce.Target != "agent-1" {
+		t.Fatalf("unexpected error detail: %+v", rce)
+	}
+
+	// A non-unit output with no value at all.
+	if _, err := decodeOutput[Money]("agent-1", "charge", witTypes.None[types.SchemaValueTree]()); err == nil {
+		t.Fatal("expected an error for a missing non-unit output")
+	}
+
+	// A unit output legitimately carries nothing.
+	if _, err := decodeOutput[Unit]("agent-1", "reset", witTypes.None[types.SchemaValueTree]()); err != nil {
+		t.Fatalf("unit output should accept no value: %v", err)
+	}
+}
+
+func TestRpcErrorsMapToDistinguishableKinds(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		in   host.RpcError
+		want RemoteErrorKind
+	}{
+		{"protocol", host.MakeRpcErrorProtocolError("bad frame"), RemoteProtocol},
+		{"denied", host.MakeRpcErrorDenied("nope"), RemoteDenied},
+		{"not found", host.MakeRpcErrorNotFound("no such agent"), RemoteNotFound},
+		{"internal", host.MakeRpcErrorRemoteInternalError("boom"), RemoteInternal},
+	} {
+		err := rpcErrorToGo("agent-1", "charge", tc.in)
+		var rce *RemoteCallError
+		if !errors.As(err, &rce) {
+			t.Fatalf("%s: expected *RemoteCallError, got %T", tc.name, err)
+		}
+		if rce.Kind != tc.want {
+			t.Errorf("%s: kind = %v, want %v", tc.name, rce.Kind, tc.want)
+		}
+		if !strings.Contains(err.Error(), "agent-1") || !strings.Contains(err.Error(), "charge") {
+			t.Errorf("%s: message should name the target and method: %s", tc.name, err)
+		}
+	}
+}
+
+// TestRemoteAgentErrorKeepsItsCause — A remote domain error must stay inspectable rather than collapsing to a string.
+func TestRemoteAgentErrorKeepsItsCause(t *testing.T) {
+	remote := common.MakeAgentErrorInvalidMethod("no such method: charge")
+	err := rpcErrorToGo("agent-1", "charge", host.MakeRpcErrorRemoteAgentError(remote))
+
+	var rce *RemoteCallError
+	if !errors.As(err, &rce) {
+		t.Fatalf("expected *RemoteCallError, got %T", err)
+	}
+	if rce.Kind != RemoteAgent {
+		t.Fatalf("kind = %v, want RemoteAgent", rce.Kind)
+	}
+	cause := errors.Unwrap(rce)
+	if cause == nil {
+		t.Fatal("a remote agent-error must be preserved as the cause")
+	}
+	if !strings.Contains(cause.Error(), "no such method") {
+		t.Fatalf("cause lost the remote detail: %v", cause)
+	}
+}
+
+// TestInvocationIDFromProjects — invocationIDFrom projects the host's invocation metadata onto the SDK's
+// public InvocationID. Pure, so it is pinned here rather than left to
+// integration.
+func TestInvocationIDFromProjects(t *testing.T) {
+	got := invocationIDFrom(host.InvocationMetadata{AgentId: "agent-7", IdempotencyKey: "key-9"})
+	if got.AgentID != "agent-7" || got.IdempotencyKey != "key-9" {
+		t.Fatalf("invocationIDFrom = %+v, want {agent-7, key-9}", got)
+	}
+}
+
+// TestInstantFromConvertsTime — instantFrom converts a Go time into the wasi clock instant used for scheduling.
+// The interesting cases are sub-second nanoseconds and pre-epoch times, where the
+// seconds go negative while the nanoseconds stay in [0, 1e9).
+func TestInstantFromConvertsTime(t *testing.T) {
+	normal := instantFrom(time.Unix(1_700_000_000, 250_000_000))
+	if normal.Seconds != 1_700_000_000 || normal.Nanoseconds != 250_000_000 {
+		t.Fatalf("instantFrom(normal) = {%d, %d}, want {1700000000, 250000000}",
+			normal.Seconds, normal.Nanoseconds)
+	}
+
+	preEpoch := instantFrom(time.Unix(-2, 500_000_000))
+	if preEpoch.Seconds != -2 || preEpoch.Nanoseconds != 500_000_000 {
+		t.Fatalf("instantFrom(pre-epoch) = {%d, %d}, want {-2, 500000000}",
+			preEpoch.Seconds, preEpoch.Nanoseconds)
+	}
+}
+
+// Note: the zero-Client guards on Call/Trigger/CallAsync and the consumed-handle
+// guard on Future.Get are straight-line nil checks, but they cannot be exercised
+// natively — referencing the wrapper pulls in its wasmimport symbols. They are
+// covered by the integration layers.
diff --git a/sdks/go/golem/schema.go b/sdks/go/golem/schema.go
new file mode 100644
index 0000000000..961f1826f1
--- /dev/null
+++ b/sdks/go/golem/schema.go
@@ -0,0 +1,223 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"reflect"
+	"sort"
+
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+	types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// The agent type carries ONE schema graph: a flat pool of type nodes, with
+// constructor and method schemas referring to it by index. Schemas are derived
+// from the Go types by reflection — this is what removes the need for a code
+// generation step or an explicit schema DSL.
+
+type graphBuilder struct {
+	nodes []types.SchemaTypeNode
+	// seen deduplicates by Go type, so a type used by several methods yields one
+	// node. Sharing is legal: a consumer tracks cycles along the current path
+	// only, so the same node reached twice by sibling paths is fine.
+	seen map[reflect.Type]int32
+	// refs maps a recursive type to its ref-type node, and defs holds the named
+	// definitions those nodes point at.
+	refs map[reflect.Type]int32
+	defs []types.SchemaTypeDef
+	// invalids collects the types this graph references that could not be
+	// compiled (see [codec.invalid]), so buildAgentType can attribute them to
+	// the agent being built.
+	invalids map[reflect.Type]string
+	// d is the definition set this graph is derived for; refNode reads its pins
+	// to resolve type-ids.
+	d *definitions
+}
+
+// node returns the index of c's type node, adding it if absent.
+//
+// The index is reserved and recorded *before* the body is built, because
+// building it may recurse back into this same type. That reservation is what
+// makes recursive types (a record reachable from its own fields) produce a
+// finite graph instead of overflowing the stack.
+func (g *graphBuilder) node(c *codec) int32 {
+	if c.invalid != "" {
+		if g.invalids == nil {
+			g.invalids = map[reflect.Type]string{}
+		}
+		g.invalids[c.typ] = c.invalid
+	}
+	if c.recursive {
+		return g.refNode(c)
+	}
+	if g.seen == nil {
+		g.seen = map[reflect.Type]int32{}
+	}
+	if idx, ok := g.seen[c.typ]; ok {
+		return idx
+	}
+	idx := int32(len(g.nodes))
+	g.nodes = append(g.nodes, types.SchemaTypeNode{})
+	g.seen[c.typ] = idx
+
+	// Sequenced deliberately: c.body may append nodes and reallocate g.nodes,
+	// so the destination must be indexed only after it returns.
+	body := c.body(g)
+	g.nodes[idx].Body = body
+	return idx
+}
+
+// refNode emits a recursive type as a named def plus the ref-type node that
+// points at it. The ref node is registered before the body is built, so when the
+// body reaches this type again it resolves to the ref instead of recursing —
+// which is what keeps the flat node list acyclic.
+func (g *graphBuilder) refNode(c *codec) int32 {
+	if g.refs == nil {
+		g.refs = map[reflect.Type]int32{}
+	}
+	if idx, ok := g.refs[c.typ]; ok {
+		return idx
+	}
+
+	defIdx := int32(len(g.defs))
+	g.defs = append(g.defs, types.SchemaTypeDef{
+		// Resolved here, at schema-build time (get-definition) — not at compile
+		// time — so a NameType pin registered during package init is honored
+		// regardless of whether the type's codec compiled first.
+		Id:   g.d.typeID(c.typ),
+		Name: witTypes.Some(c.typ.String()),
+	})
+
+	refIdx := int32(len(g.nodes))
+	g.nodes = append(g.nodes, types.SchemaTypeNode{Body: types.MakeSchemaTypeBodyRefType(defIdx)})
+	g.refs[c.typ] = refIdx
+
+	bodyIdx := int32(len(g.nodes))
+	g.nodes = append(g.nodes, types.SchemaTypeNode{})
+	body := c.body(g)
+	g.nodes[bodyIdx].Body = body
+	g.defs[defIdx].Body = bodyIdx
+
+	return refIdx
+}
+
+// sortDefs orders defs by id and rewrites the ref-type nodes accordingly, so a
+// given set of Go types always produces a byte-identical graph.
+func (g *graphBuilder) sortDefs() {
+	if len(g.defs) < 2 {
+		return
+	}
+	order := make([]int, len(g.defs))
+	for i := range order {
+		order[i] = i
+	}
+	sort.Slice(order, func(a, b int) bool { return g.defs[order[a]].Id < g.defs[order[b]].Id })
+
+	remap := make([]int32, len(g.defs))
+	sorted := make([]types.SchemaTypeDef, len(g.defs))
+	for newIdx, oldIdx := range order {
+		sorted[newIdx] = g.defs[oldIdx]
+		remap[oldIdx] = int32(newIdx)
+	}
+	g.defs = sorted
+
+	for i := range g.nodes {
+		if g.nodes[i].Body.Tag() == types.SchemaTypeBodyRefType {
+			g.nodes[i].Body = types.MakeSchemaTypeBodyRefType(remap[g.nodes[i].Body.RefType()])
+		}
+	}
+}
+
+func (g *graphBuilder) build() types.SchemaGraph {
+	// schema.root is a structurally required placeholder, not the semantic root:
+	// the meaningful roots are the per-parameter and per-output indices.
+	if len(g.nodes) == 0 {
+		g.nodes = append(g.nodes, types.SchemaTypeNode{Body: types.MakeSchemaTypeBodyBoolType()})
+	}
+	g.sortDefs()
+	return types.SchemaGraph{TypeNodes: g.nodes, Defs: g.defs, Root: 0}
+}
+
+// namedFields turns a parameter list into WIT named-fields, adding each
+// parameter's type to the shared graph.
+func namedFields(g *graphBuilder, fs []fieldInfo) []common.NamedField {
+	out := make([]common.NamedField, 0, len(fs))
+	for _, f := range fs {
+		out = append(out, common.NamedField{
+			Name:   f.name,
+			Source: common.MakeFieldSourceUserSupplied(),
+			Schema: g.node(f.codec),
+		})
+	}
+	return out
+}
+
+// buildAgentType derives the full agent-type metadata reported by
+// get-definition / discover-agent-types. The second result is the set of types
+// referenced by this agent that could not be compiled, keyed by type — empty for
+// a well-formed agent; finalize turns them into attributed definition errors.
+func (d *definitions) buildAgentType(e *agentEntry) (common.AgentType, map[reflect.Type]string) {
+	g := graphBuilder{d: d}
+
+	ctorFields := namedFields(&g, e.idFields)
+	methods := make([]common.AgentMethod, 0, len(e.order))
+	for _, name := range e.order {
+		m := e.methods[name]
+		in := namedFields(&g, m.inFields)
+		out := common.MakeOutputSchemaUnit()
+		if m.outCodec != nil {
+			out = common.MakeOutputSchemaSingle(g.node(m.outCodec))
+		}
+		readOnly := witTypes.None[common.ReadOnlyConfig]()
+		if m.readOnly != nil {
+			readOnly = witTypes.Some(common.ReadOnlyConfig{
+				CachePolicy:   m.readOnly.policy.toWit(),
+				UsesPrincipal: false,
+			})
+		}
+		methods = append(methods, common.AgentMethod{
+			Name:         m.name,
+			Description:  m.desc,
+			InputSchema:  common.MakeInputSchemaParameters(in),
+			OutputSchema: out,
+			PromptHint:   witTypes.None[string](),
+			ReadOnly:     readOnly,
+		})
+	}
+
+	// Compute config declarations before g.build(): each adds its value type to
+	// the shared graph, and ValueType indexes into the built schema.
+	configDecls := d.buildConfigDecls(&g, e.configs)
+
+	at := common.AgentType{
+		TypeName:       e.name,
+		Description:    e.desc,
+		SourceLanguage: "go",
+		Schema:         g.build(),
+		Constructor: common.AgentConstructor{
+			Name:        witTypes.None[string](),
+			Description: e.desc,
+			PromptHint:  witTypes.None[string](),
+			InputSchema: common.MakeInputSchemaParameters(ctorFields),
+		},
+		Methods:      methods,
+		Mode:         e.mode,
+		HttpMount:    witTypes.None[common.HttpMountDetails](),
+		Snapshotting: e.snapshot.toWit(),
+		Config:       configDecls,
+	}
+	return at, g.invalids
+}
diff --git a/sdks/go/golem/snapshot.go b/sdks/go/golem/snapshot.go
new file mode 100644
index 0000000000..6cd82f08f9
--- /dev/null
+++ b/sdks/go/golem/snapshot.go
@@ -0,0 +1,63 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"encoding/json"
+
+	host "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_host"
+)
+
+// Snapshotting: the host can ask the guest to serialize the running agent's
+// state (save-snapshot) and later restore it (load-snapshot) — both are guest
+// exports, wired in guest.go. The serialization itself is pure Go over the state
+// value (no host imports), so it is unit-tested directly.
+//
+// Two modes, chosen per instance:
+//   - if the state implements [Snapshotter], its Save/Load bytes are used verbatim
+//     (opaque payload);
+//   - otherwise the state's exported fields are JSON-encoded. Unexported fields
+//     are invisible to reflection, so a state with private fields must implement
+//     Snapshotter to be captured — see [Snapshotter].
+const (
+	snapshotRawMIME  = "application/octet-stream"
+	snapshotJSONMIME = "application/json"
+)
+
+// saveState serializes an agent instance's state into a host snapshot.
+func saveState(state any) (host.Snapshot, error) {
+	if sn, ok := state.(Snapshotter); ok {
+		payload, err := sn.Save()
+		if err != nil {
+			return host.Snapshot{}, err
+		}
+		return host.Snapshot{Payload: payload, MimeType: snapshotRawMIME}, nil
+	}
+	payload, err := json.Marshal(state)
+	if err != nil {
+		return host.Snapshot{}, err
+	}
+	return host.Snapshot{Payload: payload, MimeType: snapshotJSONMIME}, nil
+}
+
+// loadState restores an agent instance's state from a host snapshot. state must
+// be the same shape saveState produced the snapshot from (a pointer to the state
+// struct), so the decode writes back through it.
+func loadState(state any, snap host.Snapshot) error {
+	if sn, ok := state.(Snapshotter); ok {
+		return sn.Load(snap.Payload)
+	}
+	return json.Unmarshal(snap.Payload, state)
+}
diff --git a/sdks/go/golem/snapshot_test.go b/sdks/go/golem/snapshot_test.go
new file mode 100644
index 0000000000..2985e3cf34
--- /dev/null
+++ b/sdks/go/golem/snapshot_test.go
@@ -0,0 +1,134 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"testing"
+	"time"
+
+	common "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_agent_common"
+)
+
+// snapCustomState — A state that controls its own serialization — the only way to capture
+// unexported fields.
+type snapCustomState struct{ count int64 }
+
+func (s *snapCustomState) Save() ([]byte, error) { return []byte{byte(s.count)}, nil }
+func (s *snapCustomState) Load(b []byte) error   { s.count = int64(b[0]); return nil }
+
+func TestSnapshotViaSnapshotter(t *testing.T) {
+	src := &snapCustomState{count: 42}
+	snap, err := saveState(src)
+	if err != nil {
+		t.Fatalf("save: %v", err)
+	}
+	if snap.MimeType != snapshotRawMIME {
+		t.Errorf("MIME = %q, want %q", snap.MimeType, snapshotRawMIME)
+	}
+	dst := &snapCustomState{}
+	if err := loadState(dst, snap); err != nil {
+		t.Fatalf("load: %v", err)
+	}
+	if dst.count != 42 {
+		t.Errorf("round trip lost the count: got %d", dst.count)
+	}
+}
+
+func TestSnapshotReflectiveDefaultCoversExportedFields(t *testing.T) {
+	type State struct {
+		Total  int64
+		Region string
+	}
+	src := &State{Total: 7, Region: "eu"}
+	snap, err := saveState(src)
+	if err != nil {
+		t.Fatalf("save: %v", err)
+	}
+	if snap.MimeType != snapshotJSONMIME {
+		t.Errorf("MIME = %q, want %q", snap.MimeType, snapshotJSONMIME)
+	}
+	dst := &State{}
+	if err := loadState(dst, snap); err != nil {
+		t.Fatalf("load: %v", err)
+	}
+	if *dst != *src {
+		t.Errorf("round trip = %+v, want %+v", *dst, *src)
+	}
+}
+
+// TestSnapshotReflectiveDefaultDropsUnexportedFields — The documented caveat: without a Snapshotter, unexported fields are invisible
+// to reflection and are NOT captured.
+func TestSnapshotReflectiveDefaultDropsUnexportedFields(t *testing.T) {
+	src := &struct{ count int64 }{count: 99}
+	snap, err := saveState(src)
+	if err != nil {
+		t.Fatalf("save: %v", err)
+	}
+	if string(snap.Payload) != "{}" {
+		t.Errorf("expected empty JSON for all-unexported state, got %q", snap.Payload)
+	}
+}
+
+func TestSnapshotPolicyMapsToWit(t *testing.T) {
+	cases := []struct {
+		name    string
+		policy  SnapshotPolicy
+		enabled bool
+		cfgTag  uint8
+		amount  uint64
+	}{
+		{"disabled", SnapshotDisabled, false, 0, 0},
+		{"default", SnapshotDefault, true, common.SnapshottingConfigDefault, 0},
+		{"periodic", SnapshotPeriodic(2 * time.Second), true, common.SnapshottingConfigPeriodic, uint64(2 * time.Second)},
+		{"everyN", SnapshotEveryN(5), true, common.SnapshottingConfigEveryNInvocation, 5},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			type Id struct{ Name string }
+			type St struct{}
+			withDefs(t, func(d *definitions) {
+				defineAgentInto[Id, St](d, Spec{Name: "A", Snapshot: c.policy}, func(Id) *St { return &St{} })
+				types, errs := d.discover()
+				if len(errs) != 0 {
+					t.Fatalf("errs: %v", errs)
+				}
+				s := types[0].Snapshotting
+				if !c.enabled {
+					if s.Tag() != common.SnapshottingDisabled {
+						t.Fatalf("want disabled, got tag %d", s.Tag())
+					}
+					return
+				}
+				if s.Tag() != common.SnapshottingEnabled {
+					t.Fatalf("want enabled, got tag %d", s.Tag())
+				}
+				cfg := s.Enabled()
+				if cfg.Tag() != c.cfgTag {
+					t.Fatalf("config tag = %d, want %d", cfg.Tag(), c.cfgTag)
+				}
+				switch c.cfgTag {
+				case common.SnapshottingConfigPeriodic:
+					if cfg.Periodic() != c.amount {
+						t.Errorf("periodic = %d, want %d", cfg.Periodic(), c.amount)
+					}
+				case common.SnapshottingConfigEveryNInvocation:
+					if uint64(cfg.EveryNInvocation()) != c.amount {
+						t.Errorf("everyN = %d, want %d", cfg.EveryNInvocation(), c.amount)
+					}
+				}
+			})
+		})
+	}
+}
diff --git a/sdks/go/golem/testdata/wrong_client.go b/sdks/go/golem/testdata/wrong_client.go
new file mode 100644
index 0000000000..15efd2f4ff
--- /dev/null
+++ b/sdks/go/golem/testdata/wrong_client.go
@@ -0,0 +1,41 @@
+//go:build ignore
+
+// This file is DELIBERATELY uncompilable. It is not part of the package build
+// (the `ignore` build tag excludes it); the compile_fail test invokes `go build`
+// on it and asserts the type-checker rejects it.
+//
+// The guarantee under test: a MethodDef[Id, In, Out] can only be Called with a
+// Client[Id] for the SAME agent identity. Aiming a payment method at an order
+// client must be a COMPILE error, not a runtime not-found.
+package main
+
+import "github.com/golemcloud/golem/sdks/go/golem"
+
+type PaymentID struct{ Merchant string }
+type PaymentState struct{}
+type ChargeIn struct{ AmountCents int64 }
+
+type OrderID struct{ Number string }
+type OrderState struct{}
+
+var Payment = golem.DefineAgent[PaymentID, PaymentState](
+	golem.Spec{Name: "PaymentAgent"},
+	func(PaymentID) *PaymentState { return &PaymentState{} },
+)
+
+var Order = golem.DefineAgent[OrderID, OrderState](
+	golem.Spec{Name: "OrderAgent"},
+	func(OrderID) *OrderState { return &OrderState{} },
+)
+
+// Charge is a method of the PAYMENT agent (its Id is PaymentID).
+var Charge = golem.DefineMethod[PaymentID, ChargeIn, int64]("charge")
+
+func main() {
+	// A client for the ORDER agent — Client[OrderID].
+	orderClient := golem.ClientFor(Order, OrderID{Number: "o-1"})
+
+	// ERROR: Charge is MethodDef[PaymentID, …]; Call wants Client[PaymentID],
+	// but orderClient is Client[OrderID]. Type-check must reject this.
+	_ = Charge.Call(orderClient, ChargeIn{AmountCents: 100})
+}
diff --git a/sdks/go/golem/transaction.go b/sdks/go/golem/transaction.go
new file mode 100644
index 0000000000..3d6ca413e0
--- /dev/null
+++ b/sdks/go/golem/transaction.go
@@ -0,0 +1,170 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"fmt"
+
+	apiHost "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_host"
+)
+
+// A transaction runs a sequence of compensable [Operation]s so that if a later
+// step fails, the steps that already succeeded are rolled back by running their
+// compensations in reverse order. It builds on the durability primitives (atomic
+// region + oplog) — no persistence beyond what the runtime already provides.
+//
+// Two flavors:
+//
+//   - [FallibleTransaction] rolls back on a step error and RETURNS a
+//     [TransactionFailure] (best-effort; reports complete vs partial rollback).
+//   - [InfallibleTransaction] rolls back, rewinds the oplog to the start, and the
+//     runtime REPLAYS the whole transaction until it succeeds.
+//
+// Both share the [Operation]/[Step] building blocks. The E type parameter is the
+// common error type across a transaction's steps (often string). Model expected
+// step failures as the error arm of the step's [Result]; a panic (an infra
+// failure) leaves the atomic region open so the runtime replays it, matching the
+// fail-loud model used elsewhere in the SDK.
+//
+// Concurrency: a transaction opens a worker-GLOBAL atomic region (Golem has no
+// per-task scope). Because the agent runs single-threaded with cooperative
+// task-switching only at await points, keep the whole transaction on one logical
+// flow — do not run concurrent goroutines that perform durable side effects while
+// a transaction is open, or their operations fall inside its region. See the
+// concurrency note in durability.go.
+
+// Operation is a compensable step: an action paired with the rollback to undo it.
+// compensate receives both the original input and the output execute produced, and
+// runs only if a later step in the same transaction fails. Build one with
+// [NewOperation].
+type Operation[In, Out, E any] struct {
+	execute    func(In) Result[Out, E]
+	compensate func(In, Out) Result[Unit, E]
+}
+
+// NewOperation builds an [Operation] from an execute action and its compensation.
+// execute reports an expected failure as the error arm of its [Result]; compensate
+// should be best-effort and idempotent — it may run during rollback.
+func NewOperation[In, Out, E any](
+	execute func(In) Result[Out, E],
+	compensate func(In, Out) Result[Unit, E],
+) Operation[In, Out, E] {
+	return Operation[In, Out, E]{execute: execute, compensate: compensate}
+}
+
+// Transaction accumulates the compensations of the steps that have succeeded so
+// far. Obtain one from [FallibleTransaction] or [InfallibleTransaction] and pass
+// it to [Step]; do not construct it directly.
+type Transaction[E any] struct {
+	compensations []func() Result[Unit, E]
+}
+
+// compensate runs the recorded compensations in reverse order and returns the
+// first failure seen (None if all succeeded). Pure — no host interaction.
+func (tx *Transaction[E]) compensate() Option[E] {
+	for i := len(tx.compensations) - 1; i >= 0; i-- {
+		if r := tx.compensations[i](); r.IsErr() {
+			return Some(r.Err())
+		}
+	}
+	return None[E]()
+}
+
+// Step runs op against input inside tx. On success it records op's compensation
+// (to be run if the transaction later rolls back) and returns the Ok result; on
+// failure it returns the error result — return it from the transaction body to
+// trigger rollback. It is a free function because Go methods cannot take type
+// parameters, mirroring [MethodDef.Call].
+func Step[In, Out, E any](tx *Transaction[E], op Operation[In, Out, E], input In) Result[Out, E] {
+	r := op.execute(input)
+	if r.IsErr() {
+		return r
+	}
+	out := r.Ok()
+	tx.compensations = append(tx.compensations, func() Result[Unit, E] {
+		return op.compensate(input, out)
+	})
+	return r
+}
+
+// TransactionFailure is the error arm of a [FallibleTransaction]: the step failure
+// that aborted it, plus whether the rollback itself fully succeeded.
+type TransactionFailure[E any] struct {
+	// Error is the step failure that aborted the transaction.
+	Error E
+	// CompensationFailure is Some when a compensation itself failed during
+	// rollback (a partial rollback); None means every compensation succeeded (a
+	// complete rollback).
+	CompensationFailure Option[E]
+}
+
+// RolledBackFully reports whether every compensation succeeded (a complete
+// rollback). When false, some effects may remain and need manual attention.
+func (f TransactionFailure[E]) RolledBackFully() bool {
+	return f.CompensationFailure.IsNone()
+}
+
+// FallibleTransaction runs f as a transaction. If f returns Ok, the transaction
+// commits and its value is returned. If f returns an error, the recorded
+// compensations run in reverse (best-effort) and a [TransactionFailure] is
+// returned — there is no retry. A panic in f (an infra failure) leaves the atomic
+// region open so the runtime replays it.
+func FallibleTransaction[Out, E any](f func(*Transaction[E]) Result[Out, E]) Result[Out, TransactionFailure[E]] {
+	begin := apiHost.MarkBeginOperation()
+	out := runFallible(&Transaction[E]{}, f)
+	apiHost.MarkEndOperation(begin)
+	return out
+}
+
+// runFallible is the host-free core of [FallibleTransaction]: run the body, roll
+// back on error, assemble the result. Split out so it is natively testable.
+func runFallible[Out, E any](tx *Transaction[E], f func(*Transaction[E]) Result[Out, E]) Result[Out, TransactionFailure[E]] {
+	r := f(tx)
+	if r.IsErr() {
+		return Err[Out, TransactionFailure[E]](TransactionFailure[E]{
+			Error:               r.Err(),
+			CompensationFailure: tx.compensate(),
+		})
+	}
+	return Ok[Out, TransactionFailure[E]](r.Ok())
+}
+
+// InfallibleTransaction runs f as a transaction that retries until it succeeds. If
+// f returns Ok, its value is returned. If f returns an error, the recorded
+// compensations run in reverse, the oplog is rewound to the transaction start, and
+// the runtime replays the whole transaction. Use it only when the steps are
+// expected to eventually succeed — a deterministic failure would retry forever.
+func InfallibleTransaction[Out, E any](f func(*Transaction[E]) Result[Out, E]) Out {
+	begin := apiHost.MarkBeginOperation()
+	txBegin := apiHost.GetOplogIndex()
+
+	tx := &Transaction[E]{}
+	r := f(tx)
+	if r.IsErr() {
+		if compFail := tx.compensate(); compFail.IsSome() {
+			// A compensation failed while rolling back for a retry — the
+			// transaction cannot be made consistent, so fail loudly, surfacing
+			// which compensation failed.
+			panic(fmt.Errorf("golem: compensation failed during an infallible transaction rollback: %v", compFail.Unwrap()))
+		}
+		// Rewind to the start; this interrupts the invocation and the runtime
+		// replays the transaction, so it does not return.
+		apiHost.SetOplogIndex(txBegin)
+		panic(fmt.Errorf("golem: unreachable after oplog rewind"))
+	}
+
+	apiHost.MarkEndOperation(begin)
+	return r.Ok()
+}
diff --git a/sdks/go/golem/transaction_test.go b/sdks/go/golem/transaction_test.go
new file mode 100644
index 0000000000..1af22969df
--- /dev/null
+++ b/sdks/go/golem/transaction_test.go
@@ -0,0 +1,162 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"testing"
+)
+
+// tracker records execute/compensate calls in order, so tests can assert that
+// compensations run in reverse.
+type tracker struct{ calls []string }
+
+// okOp is an operation that succeeds (recording "e<tag>") and whose compensation
+// succeeds (recording "c<tag>").
+func okOp(tr *tracker, tag string) Operation[int, int, string] {
+	return NewOperation(
+		func(in int) Result[int, string] {
+			tr.calls = append(tr.calls, "e"+tag)
+			return Ok[int, string](in + 1)
+		},
+		func(in, out int) Result[Unit, string] {
+			tr.calls = append(tr.calls, "c"+tag)
+			return Ok[Unit, string](Unit{})
+		},
+	)
+}
+
+// failOp is an operation whose execute fails, recording "e<tag>".
+func failOp(tr *tracker, tag, reason string) Operation[int, int, string] {
+	return NewOperation(
+		func(in int) Result[int, string] {
+			tr.calls = append(tr.calls, "e"+tag)
+			return Err[int, string](reason)
+		},
+		func(in, out int) Result[Unit, string] {
+			tr.calls = append(tr.calls, "c"+tag)
+			return Ok[Unit, string](Unit{})
+		},
+	)
+}
+
+func eq(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
+// TestFallibleCommit — every step succeeds: no compensation runs and the value is
+// returned.
+func TestFallibleCommit(t *testing.T) {
+	tr := &tracker{}
+	a, b := okOp(tr, "1"), okOp(tr, "2")
+	out := runFallible(&Transaction[string]{}, func(tx *Transaction[string]) Result[int, string] {
+		r1 := Step(tx, a, 10)
+		r2 := Step(tx, b, r1.Ok())
+		return Ok[int, string](r2.Ok())
+	})
+	if out.IsErr() {
+		t.Fatalf("expected commit, got %+v", out.Err())
+	}
+	if out.Ok() != 12 {
+		t.Fatalf("value = %d, want 12", out.Ok())
+	}
+	if !eq(tr.calls, []string{"e1", "e2"}) {
+		t.Fatalf("calls = %v, want [e1 e2] (no compensation)", tr.calls)
+	}
+}
+
+// TestFallibleRollbackComplete — a mid-transaction failure compensates the
+// already-succeeded steps in REVERSE order, and reports a complete rollback.
+func TestFallibleRollbackComplete(t *testing.T) {
+	tr := &tracker{}
+	a, b := okOp(tr, "1"), okOp(tr, "2")
+	bad := failOp(tr, "3", "boom")
+	out := runFallible(&Transaction[string]{}, func(tx *Transaction[string]) Result[int, string] {
+		if r := Step(tx, a, 1); r.IsErr() {
+			return r
+		}
+		if r := Step(tx, b, 2); r.IsErr() {
+			return r
+		}
+		if r := Step(tx, bad, 3); r.IsErr() {
+			return r
+		}
+		return Ok[int, string](0)
+	})
+	if !out.IsErr() {
+		t.Fatal("expected failure")
+	}
+	f := out.Err()
+	if f.Error != "boom" {
+		t.Fatalf("error = %q, want boom", f.Error)
+	}
+	if !f.RolledBackFully() {
+		t.Fatalf("expected complete rollback, got partial: %+v", f.CompensationFailure)
+	}
+	// e1,e2 succeeded and recorded compensations; e3 failed (no compensation).
+	// Rollback runs c2 then c1 (reverse).
+	if !eq(tr.calls, []string{"e1", "e2", "e3", "c2", "c1"}) {
+		t.Fatalf("calls = %v, want [e1 e2 e3 c2 c1]", tr.calls)
+	}
+}
+
+// TestFallibleRollbackPartial — a compensation that itself fails is reported as a
+// partial rollback carrying the compensation's error.
+func TestFallibleRollbackPartial(t *testing.T) {
+	tr := &tracker{}
+	// a's compensation fails; b succeeds; c fails execution to trigger rollback.
+	a := NewOperation(
+		func(in int) Result[int, string] { tr.calls = append(tr.calls, "ea"); return Ok[int, string](in) },
+		func(in, out int) Result[Unit, string] {
+			tr.calls = append(tr.calls, "ca")
+			return Err[Unit, string]("ca-failed")
+		},
+	)
+	b := okOp(tr, "b")
+	bad := failOp(tr, "c", "boom")
+	out := runFallible(&Transaction[string]{}, func(tx *Transaction[string]) Result[int, string] {
+		if r := Step(tx, a, 1); r.IsErr() {
+			return r
+		}
+		if r := Step(tx, b, 2); r.IsErr() {
+			return r
+		}
+		if r := Step(tx, bad, 3); r.IsErr() {
+			return r
+		}
+		return Ok[int, string](0)
+	})
+	f := out.Err()
+	if f.Error != "boom" {
+		t.Fatalf("error = %q, want boom", f.Error)
+	}
+	if f.RolledBackFully() {
+		t.Fatal("expected partial rollback")
+	}
+	if cf, _ := f.CompensationFailure.Get(); cf != "ca-failed" {
+		t.Fatalf("compensation failure = %q, want ca-failed", cf)
+	}
+	// Rollback runs cb (ok) then ca (fails).
+	if !eq(tr.calls, []string{"ea", "eb", "ec", "cb", "ca"}) {
+		t.Fatalf("calls = %v, want [ea eb ec cb ca]", tr.calls)
+	}
+}
diff --git a/sdks/go/golem/types.go b/sdks/go/golem/types.go
new file mode 100644
index 0000000000..94084b4351
--- /dev/null
+++ b/sdks/go/golem/types.go
@@ -0,0 +1,357 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// SDK-owned counterparts of the WIT types that Go has no native spelling for.
+//
+// Their fields are unexported and they are built through constructors, so an
+// inconsistent value (an "ok" result carrying an error, say) cannot be
+// constructed. The codec reaches into them through the unexported interfaces
+// below rather than by field reflection — which is also why these cannot be the
+// wit-bindgen types: those have unexported fields and no accessors, so
+// reflection can neither read nor write them.
+
+// ---------------------------------------------------------------------------
+// Option
+// ---------------------------------------------------------------------------
+
+// Option is an explicit optional value.
+//
+// A plain *T means option<T> too, and is the idiomatic spelling for a struct
+// field. Reach for Option[T] when a pointer would be ambiguous or awkward —
+// most often when nesting, where Option[Option[T]] reads far better than **T.
+// Both produce exactly the same schema.
+type Option[T any] struct {
+	some  bool
+	value T
+}
+
+// Some returns an Option holding v.
+func Some[T any](v T) Option[T] { return Option[T]{some: true, value: v} }
+
+// None returns an empty Option.
+func None[T any]() Option[T] { return Option[T]{} }
+
+// IsSome reports whether a value is present.
+func (o Option[T]) IsSome() bool { return o.some }
+
+// IsNone reports whether the Option is empty.
+func (o Option[T]) IsNone() bool { return !o.some }
+
+// Get returns the value and whether it was present — the comma-ok form.
+func (o Option[T]) Get() (T, bool) { return o.value, o.some }
+
+// Or returns the value if present, otherwise def.
+func (o Option[T]) Or(def T) T {
+	if o.some {
+		return o.value
+	}
+	return def
+}
+
+// Unwrap returns the value, panicking if the Option is empty. Use Get when
+// absence is expected.
+func (o Option[T]) Unwrap() T {
+	if !o.some {
+		panic(fmt.Errorf("golem: Unwrap on an empty Option"))
+	}
+	return o.value
+}
+
+// optionish is the codec plumbing for Option, resolved once at compile time
+// against the zero value, so there is no per-value type switching and no unsafe
+// field access.
+type optionish interface {
+	optionElem() reflect.Type
+	optionGet() (reflect.Value, bool)
+}
+
+type optionSetter interface {
+	optionSetNone()
+	optionSetSome() reflect.Value
+}
+
+func (o Option[T]) optionElem() reflect.Type { return reflect.TypeFor[T]() }
+
+func (o Option[T]) optionGet() (reflect.Value, bool) {
+	return reflect.ValueOf(&o.value).Elem(), o.some
+}
+
+func (o *Option[T]) optionSetNone() {
+	var zero T
+	o.some, o.value = false, zero
+}
+
+func (o *Option[T]) optionSetSome() reflect.Value {
+	o.some = true
+	return reflect.ValueOf(&o.value).Elem()
+}
+
+// ---------------------------------------------------------------------------
+// Result
+// ---------------------------------------------------------------------------
+
+// Result is a value that is either a success or a typed failure.
+//
+// It is not how a method reports failure — a handler panics for that, which
+// surfaces as the WIT agent-error channel. Result is for a fallible value
+// delivered on a *successful* invocation: a return value the caller inspects, a
+// field, a list element, one arm of another Result. That distinction mirrors the
+// TS SDK, where a Result lowers to a component-model result inside the success
+// payload while throws stay on the agent-error channel.
+type Result[Ok any, Err any] struct {
+	isErr bool
+	ok    Ok
+	err   Err
+}
+
+// Ok returns a successful Result. Both type parameters are explicit because
+// neither can be inferred from the argument alone:
+//
+//	golem.Ok[Money, string](m)
+func Ok[O any, E any](v O) Result[O, E] { return Result[O, E]{ok: v} }
+
+// Err returns a failed Result.
+func Err[O any, E any](e E) Result[O, E] { return Result[O, E]{isErr: true, err: e} }
+
+// IsOk reports whether the Result is a success.
+func (r Result[Ok, Err]) IsOk() bool { return !r.isErr }
+
+// IsErr reports whether the Result is a failure.
+func (r Result[Ok, Err]) IsErr() bool { return r.isErr }
+
+// Ok returns the typed success value, panicking (with the Err payload) if the
+// Result is a failure. Check IsOk first, use the typed [Result.Err], or use
+// [Result.Get] to bridge to (value, error).
+func (r Result[Ok, Err]) Ok() Ok {
+	if r.isErr {
+		panic(fmt.Errorf("golem: Result.Ok() on a failed Result: %v", r.err))
+	}
+	return r.ok
+}
+
+// Err returns the typed failure value, panicking if the Result is a success.
+func (r Result[Ok, Err]) Err() Err {
+	if !r.isErr {
+		panic(fmt.Errorf("golem: Result.Err() on a successful Result"))
+	}
+	return r.err
+}
+
+// Get bridges the Result to idiomatic Go (value, error): it returns the success
+// value and a nil error, or the zero value and an error carrying the Err arm. A
+// data-typed Err (string, struct, enum) is wrapped in a [ResultError] that keeps
+// the typed payload recoverable via [errors.As]; an Err that already implements
+// error is returned as-is. Compose with [Must] to treat the failure as fatal:
+//
+//	total, err := ledger.Record.Call(l, in).Get()  // handle
+//	total := golem.Must(ledger.Record.Call(l, in).Get())  // or fail-loud
+//
+// Use the typed [Result.Ok]/[Result.Err] instead when you want the Err value in
+// its own type rather than as an error.
+func (r Result[Ok, Err]) Get() (Ok, error) {
+	if r.isErr {
+		var zero Ok
+		return zero, asGoError(r.err)
+	}
+	return r.ok, nil
+}
+
+// OkOr returns the success value if present, otherwise def.
+func (r Result[Ok, Err]) OkOr(def Ok) Ok {
+	if r.isErr {
+		return def
+	}
+	return r.ok
+}
+
+// ResultError adapts a data-typed Err arm (one that is not itself an error) into
+// a Go error, so [Result.Get] can bridge to (value, error) without flattening the
+// typed payload — recover it with [errors.As]:
+//
+//	_, err := res.Get()
+//	var re *golem.ResultError[string]
+//	if errors.As(err, &re) { use(re.Value) }
+type ResultError[E any] struct{ Value E }
+
+func (e *ResultError[E]) Error() string { return fmt.Sprintf("%v", e.Value) }
+
+// asGoError turns an Err-arm value into a Go error: the value itself if it already
+// implements error, otherwise a ResultError wrapper preserving the typed payload.
+func asGoError[E any](e E) error {
+	if err, ok := any(e).(error); ok {
+		return err
+	}
+	return &ResultError[E]{Value: e}
+}
+
+type resultish interface {
+	resultElems() (ok, err reflect.Type)
+	resultGet() (v reflect.Value, isErr bool)
+}
+
+type resultSetter interface {
+	resultSetOk() reflect.Value
+	resultSetErr() reflect.Value
+}
+
+func (r Result[Ok, Err]) resultElems() (reflect.Type, reflect.Type) {
+	return reflect.TypeFor[Ok](), reflect.TypeFor[Err]()
+}
+
+func (r Result[Ok, Err]) resultGet() (reflect.Value, bool) {
+	if r.isErr {
+		return reflect.ValueOf(&r.err).Elem(), true
+	}
+	return reflect.ValueOf(&r.ok).Elem(), false
+}
+
+func (r *Result[Ok, Err]) resultSetOk() reflect.Value {
+	r.isErr = false
+	return reflect.ValueOf(&r.ok).Elem()
+}
+
+func (r *Result[Ok, Err]) resultSetErr() reflect.Value {
+	r.isErr = true
+	return reflect.ValueOf(&r.err).Elem()
+}
+
+// ---------------------------------------------------------------------------
+// Markers
+// ---------------------------------------------------------------------------
+
+// Char is a single Unicode code point, lowering to the WIT char type. Go's rune
+// is an alias for int32 and so is indistinguishable from a plain integer; this
+// named type is what makes the intent visible to the deriver.
+type Char rune
+
+// URL is a string constrained to a URL, lowering to the WIT url type.
+type URL string
+
+// Secret is a handle to a declared config secret, obtained from the agent's
+// config ([Agent.Config] / [InitContext.Config]). It lowers to the WIT secret
+// type. [Secret.Get] reads the CURRENT plaintext from the host on each call, so a
+// rotated value is observed; the payload stays redacted in logs. A Secret cannot
+// be constructed from a plaintext and cannot be a method parameter or return
+// value — it is config-only.
+type Secret[T any] struct {
+	// read fetches the current value from the host. It is installed by config
+	// materialization (see secretBindPath); a zero-value Secret has none.
+	read func() (T, error)
+}
+
+// Get reads the secret's current plaintext from the host and returns it, or
+// panics if the read fails. Because it re-reads on every call, a rotated secret
+// is observed rather than a stale snapshot. A secret read failing is a hard
+// failure with no in-band recovery, so — like the TS/Rust/Scala SDKs — Get fails
+// loud: the panic is recovered by the invoke dispatcher into an agent-error. Must
+// be called inside an invocation (it calls the host).
+func (s Secret[T]) Get() T {
+	if s.read == nil {
+		// Only reachable for a zero-value Secret — one never obtained from config
+		// (e.g. `var s Secret[string]`). That is a programming mistake, not an
+		// operational state; Go cannot forbid the zero value of an exported struct,
+		// so this guard turns the otherwise-cryptic nil-closure panic into a clear
+		// message.
+		panic(fmt.Errorf("golem: Secret has no source; obtain it from the agent's config"))
+	}
+	v, err := s.read()
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// String keeps secrets out of logs and error messages formatted with %v or %s.
+func (s Secret[T]) String() string { return "golem.Secret(redacted)" }
+
+// GoString does the same for %#v.
+func (s Secret[T]) GoString() string { return "golem.Secret(redacted)" }
+
+// secretish identifies a Secret[T] by its inner type — used for config-leaf
+// detection ([isSecretType]) and for building the secret(inner) schema node.
+type secretish interface{ secretElem() reflect.Type }
+
+// secretBinder installs the live-read closure during config materialization. It
+// is driven by reflection ([readSecretLeaf]) because the inner T is not
+// statically known there.
+type secretBinder interface{ secretBindPath(path []string) }
+
+func (s Secret[T]) secretElem() reflect.Type { return reflect.TypeFor[T]() }
+
+func (s *Secret[T]) secretBindPath(path []string) {
+	s.read = func() (T, error) { return readSecretValue[T](defs, path) }
+}
+
+// ---------------------------------------------------------------------------
+// (value, error) bridges
+// ---------------------------------------------------------------------------
+
+// Must adapts an ordinary Go (value, error) call into the panic-as-failure
+// model: it returns the value, or panics if err is non-nil. Go's multi-value
+// passing lets a call be dropped straight in:
+//
+//	n := golem.Must(strconv.Atoi(ctx.State.raw))
+//
+// Use it for failures that should abort the invocation. For an expected outcome
+// the caller should inspect, produce a [Result] instead (see [ResultOf]).
+func Must[T any](v T, err error) T {
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// ResultOf turns a Go (value, error) pair into a Result value, so a fallible
+// call can be surfaced to the caller as data rather than aborting:
+//
+//	return golem.ResultOf(strconv.Atoi(s))   // Result[int, string]
+//
+// The error becomes the Err arm as its message string (Go's error is an
+// interface with no wire schema; the string is what crosses the boundary).
+func ResultOf[T any](v T, err error) Result[T, string] {
+	if err != nil {
+		return Err[T, string](err.Error())
+	}
+	return Ok[T, string](v)
+}
+
+// Must2 is Must for the common (value, extra, error) shape — e.g. Go API
+// clients that return (result, *http.Response, error). It returns the first two
+// values, or panics if err is non-nil:
+//
+//	repo, _ := golem.Must2(gh.Repositories.Get(ctx, "owner", "name"))
+func Must2[A any, B any](a A, b B, err error) (A, B) {
+	if err != nil {
+		panic(err)
+	}
+	return a, b
+}
+
+// Must0 is Must for a call that returns only an error: it panics if err is
+// non-nil and otherwise does nothing. Use it to abort the invocation on a
+// fallible, side-effecting call that yields no value:
+//
+//	golem.Must0(bucket.Set(key, value))
+func Must0(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
diff --git a/sdks/go/golem/types_test.go b/sdks/go/golem/types_test.go
new file mode 100644
index 0000000000..aacbc66824
--- /dev/null
+++ b/sdks/go/golem/types_test.go
@@ -0,0 +1,110 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestOptionHelpers(t *testing.T) {
+	s := Some(7)
+	if !s.IsSome() || s.IsNone() {
+		t.Fatal("Some should be present")
+	}
+	if v, ok := s.Get(); !ok || v != 7 {
+		t.Fatalf("Get = %d,%v", v, ok)
+	}
+	if s.Or(9) != 7 || s.Unwrap() != 7 {
+		t.Fatal("Or/Unwrap on present")
+	}
+
+	n := None[int]()
+	if n.IsSome() || !n.IsNone() {
+		t.Fatal("None should be empty")
+	}
+	if _, ok := n.Get(); ok {
+		t.Fatal("None Get reports present")
+	}
+	if n.Or(9) != 9 {
+		t.Fatal("Or should return the default")
+	}
+	mustPanic(t, "empty Option", func() { n.Unwrap() })
+}
+
+func TestResultHelpers(t *testing.T) {
+	ok := Ok[int, string](3)
+	if !ok.IsOk() || ok.IsErr() || ok.Ok() != 3 || ok.OkOr(9) != 3 {
+		t.Fatal("Ok result")
+	}
+	if v, err := ok.Get(); err != nil || v != 3 {
+		t.Fatalf("Get = %d,%v", v, err)
+	}
+
+	er := Err[int, string]("boom")
+	if er.IsOk() || !er.IsErr() || er.Err() != "boom" || er.OkOr(9) != 9 {
+		t.Fatal("Err result")
+	}
+
+	mustPanic(t, "Result.Ok() on a failed Result", func() { er.Ok() })
+	mustPanic(t, "Result.Err() on a successful Result", func() { ok.Err() })
+}
+
+// TestResultGetBridgesToError — Get returns (value, error): nil error on Ok, and
+// on Err a ResultError carrying the typed payload (recoverable via errors.As).
+func TestResultGetBridgesToError(t *testing.T) {
+	if v, err := Ok[int, string](3).Get(); err != nil || v != 3 {
+		t.Fatalf("Ok.Get() = %d, %v", v, err)
+	}
+
+	_, err := Err[int, string]("boom").Get()
+	if err == nil || err.Error() != "boom" {
+		t.Fatalf("Err.Get() error = %v", err)
+	}
+	var re *ResultError[string]
+	if !errors.As(err, &re) || re.Value != "boom" {
+		t.Fatalf("errors.As did not recover the typed payload: %v", err)
+	}
+
+	// An Err arm that already implements error is passed through unwrapped.
+	sentinel := errors.New("native")
+	_, err = Err[int, error](sentinel).Get()
+	if !errors.Is(err, sentinel) {
+		t.Fatalf("native-error Err arm should pass through: %v", err)
+	}
+}
+
+func TestBridges(t *testing.T) {
+	if Must(7, nil) != 7 {
+		t.Fatal("Must should return the value")
+	}
+	mustPanic(t, "bang", func() { Must(0, errors.New("bang")) })
+
+	if r := ResultOf(5, nil); !r.IsOk() || r.Ok() != 5 {
+		t.Fatal("ResultOf(nil) should be Ok")
+	}
+	if r := ResultOf(0, errors.New("nope")); !r.IsErr() || r.Err() != "nope" {
+		t.Fatal("ResultOf(err) should carry the message")
+	}
+
+	a, b := Must2("a", 2, nil)
+	if a != "a" || b != 2 {
+		t.Fatalf("Must2 = %q,%d", a, b)
+	}
+	mustPanic(t, "bad", func() { Must2("", 0, errors.New("bad")) })
+
+	Must0(nil) // no panic on success
+	mustPanic(t, "boom0", func() { Must0(errors.New("boom0")) })
+}
diff --git a/sdks/go/golem/uuid/uuid.go b/sdks/go/golem/uuid/uuid.go
new file mode 100644
index 0000000000..d60ecb221c
--- /dev/null
+++ b/sdks/go/golem/uuid/uuid.go
@@ -0,0 +1,28 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 uuid holds the SDK's 128-bit identifier as a tiny leaf type, so
+// capability wrappers (e.g. rdbms/postgres) can use it without importing the
+// whole agent runtime. The root golem package re-exports it as golem.UUID.
+package uuid
+
+import "fmt"
+
+// UUID is a 128-bit identifier (big-endian byte order).
+type UUID [16]byte
+
+// String renders the canonical 8-4-4-4-12 hex form.
+func (u UUID) String() string {
+	return fmt.Sprintf("%x-%x-%x-%x-%x", u[0:4], u[4:6], u[6:8], u[8:10], u[10:16])
+}
diff --git a/sdks/go/golem/variant.go b/sdks/go/golem/variant.go
new file mode 100644
index 0000000000..362b3a6920
--- /dev/null
+++ b/sdks/go/golem/variant.go
@@ -0,0 +1,162 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 golem
+
+import (
+	"reflect"
+)
+
+// Go has no sum types, so a WIT variant is expressed as an interface plus the
+// set of concrete types that inhabit it. The set has to be declared rather than
+// discovered: Go offers no way to enumerate a package's implementors of an
+// interface, and the wire format needs a stable case order anyway.
+//
+//	type PaymentMethod interface{ isPaymentMethod() }
+//
+//	type Card struct{ Number string }
+//	func (Card) isPaymentMethod() {}
+//
+//	type Cash struct{}
+//	func (Cash) isPaymentMethod() {}
+//
+//	var _ = golem.DefineVariant[PaymentMethod](
+//	    golem.Case[Card]("card"),
+//	    golem.Case[Cash]("cash"),
+//	)
+//
+// An unexported marker method keeps the set closed: no type outside the
+// declaring package can join the variant.
+
+// CaseDef is one case of a variant, produced by [Case].
+type CaseDef struct {
+	name string
+	typ  reflect.Type
+}
+
+// Case declares a variant case: the payload type T, carried under name on the
+// wire.
+func Case[T any](name string) CaseDef {
+	return CaseDef{name: name, typ: reflect.TypeFor[T]()}
+}
+
+// variantDef is the registered case list for one interface type. Case order is
+// declaration order, and it is the wire order — reordering [DefineVariant]'s
+// arguments is a breaking change.
+type variantDef struct {
+	iface reflect.Type
+	cases []CaseDef
+}
+
+// DefineVariant registers the closed set of types inhabiting the interface
+// Iface. Call it from a package-level var so registration happens before the
+// component is invoked.
+// Thin wrapper over the package-global defs — keep all logic in
+// [defineVariantInto] so it stays testable against an explicit *definitions.
+// See [defs].
+func DefineVariant[Iface any](cases ...CaseDef) *variantDef {
+	return defineVariantInto[Iface](defs, cases...)
+}
+
+// defineVariantInto is the instance-scoped implementation behind DefineVariant.
+func defineVariantInto[Iface any](d *definitions, cases ...CaseDef) *variantDef {
+	it := reflect.TypeFor[Iface]()
+	vd := &variantDef{iface: it, cases: cases}
+	if it.Kind() != reflect.Interface {
+		d.recordErr("", "", "DefineVariant requires an interface type, got %s", it)
+		return vd
+	}
+	if _, dup := d.variants[it]; dup {
+		d.recordErr("", "", "variant already defined for %s", it)
+		return vd
+	}
+	if len(cases) == 0 {
+		d.recordErr("", "", "DefineVariant[%s] needs at least one case", it)
+	}
+
+	seen := map[string]bool{}
+	seenType := map[reflect.Type]bool{}
+	for _, c := range cases {
+		if !c.typ.Implements(it) && !reflect.PointerTo(c.typ).Implements(it) {
+			d.recordErr("", "", "variant case %s (%s) does not implement %s", c.name, c.typ, it)
+		}
+		if seen[c.name] {
+			d.recordErr("", "", "variant %s has duplicate case name %q", it, c.name)
+		}
+		if seenType[c.typ] {
+			// The wire case is chosen by the value's dynamic type, so one type
+			// cannot map to two case names unambiguously.
+			d.recordErr("", "", "variant %s uses case type %s more than once", it, c.typ)
+		}
+		seen[c.name] = true
+		seenType[c.typ] = true
+	}
+
+	// Registered even with soft errors above, so downstream codec compilation
+	// resolves the interface as a variant instead of cascading a second error.
+	d.variants[it] = vd
+	return vd
+}
+
+// ---------------------------------------------------------------------------
+// enums
+// ---------------------------------------------------------------------------
+
+// enumDef is the registered name list for one named integer type. A value's
+// wire representation is its position in this list, so the Go constants are
+// expected to run 0..n-1 in declaration order.
+type enumDef struct {
+	typ   reflect.Type
+	names []string
+}
+
+// DefineEnum registers a named integer type as a WIT enum:
+//
+//	type Status int32
+//	const (
+//	    StatusActive Status = iota
+//	    StatusClosed
+//	)
+//
+//	var _ = golem.DefineEnum[Status]("active", "closed")
+//
+// Values are positional: Status(0) is "active". A value outside 0..len(names)-1
+// is rejected at encode time rather than silently truncated.
+// Thin wrapper over the package-global defs — keep all logic in [defineEnumInto]
+// so it stays testable against an explicit *definitions. See [defs].
+func DefineEnum[T any](names ...string) *enumDef {
+	return defineEnumInto[T](defs, names...)
+}
+
+// defineEnumInto is the instance-scoped implementation behind DefineEnum.
+func defineEnumInto[T any](d *definitions, names ...string) *enumDef {
+	t := reflect.TypeFor[T]()
+	ed := &enumDef{typ: t, names: names}
+	switch t.Kind() {
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+	default:
+		d.recordErr("", "", "DefineEnum requires a named integer type, got %s (kind %s)", t, t.Kind())
+		return ed
+	}
+	if _, dup := d.enums[t]; dup {
+		d.recordErr("", "", "enum already defined for %s", t)
+		return ed
+	}
+	if len(names) == 0 {
+		d.recordErr("", "", "DefineEnum[%s] needs at least one name", t)
+	}
+	d.enums[t] = ed
+	return ed
+}
diff --git a/sdks/go/golem/websocket/websocket.go b/sdks/go/golem/websocket/websocket.go
new file mode 100644
index 0000000000..c55acf237c
--- /dev/null
+++ b/sdks/go/golem/websocket/websocket.go
@@ -0,0 +1,210 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 websocket is a Go wrapper over Golem's durable WebSocket client
+// (golem:websocket). Connect to a URL, then Send/Receive text or binary frames.
+//
+// Like the other WASI wrappers, operations return an error (a receive timeout is
+// reported as ok=false, not an error), distinct from the fail-loud control-flow
+// surface. The connection is durable — sends/receives are journaled and replayed
+// — and because they are remote side effects, using it inside a read-only method
+// traps.
+//
+// Pair a fallible call with golem.Must / golem.Must0 / golem.Must2 to abort the
+// invocation on error.
+package websocket
+
+import (
+	"fmt"
+	"time"
+
+	client "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_websocket_client"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// ── Messages ──────────────────────────────────────────────────────────────────
+
+// Message is a WebSocket frame — either text or binary. Build one with
+// [TextMessage] or [BinaryMessage].
+type Message struct {
+	binary bool
+	text   string
+	data   []byte
+}
+
+// TextMessage builds a text frame.
+func TextMessage(s string) Message { return Message{text: s} }
+
+// BinaryMessage builds a binary frame.
+func BinaryMessage(b []byte) Message { return Message{binary: true, data: b} }
+
+// IsText reports whether the message is a text frame.
+func (m Message) IsText() bool { return !m.binary }
+
+// IsBinary reports whether the message is a binary frame.
+func (m Message) IsBinary() bool { return m.binary }
+
+// Text returns the text payload (empty for a binary frame).
+func (m Message) Text() string { return m.text }
+
+// Bytes returns the binary payload (nil for a text frame).
+func (m Message) Bytes() []byte { return m.data }
+
+func (m Message) toWit() client.Message {
+	if m.binary {
+		return client.MakeMessageBinary(m.data)
+	}
+	return client.MakeMessageText(m.text)
+}
+
+func messageFromWit(m client.Message) Message {
+	if m.Tag() == client.MessageBinary {
+		return Message{binary: true, data: m.Binary()}
+	}
+	return Message{text: m.Text()}
+}
+
+// ── Errors ────────────────────────────────────────────────────────────────────
+
+// ErrorKind classifies a [Error].
+type ErrorKind uint8
+
+const (
+	ConnectionFailure ErrorKind = iota
+	SendFailure
+	ReceiveFailure
+	ProtocolError
+	// Closed means the peer closed the connection; CloseCode/CloseReason may carry
+	// the close frame.
+	Closed
+	Other
+)
+
+// Error is a WebSocket host error.
+type Error struct {
+	Kind        ErrorKind
+	Message     string
+	CloseCode   uint16
+	CloseReason string
+}
+
+func (e *Error) Error() string { return "golem/websocket: " + e.Message }
+
+// IsClosed reports whether the error is a peer close.
+func (e *Error) IsClosed() bool { return e.Kind == Closed }
+
+func wsError(e client.Error) error {
+	switch e.Tag() {
+	case client.ErrorConnectionFailure:
+		return &Error{Kind: ConnectionFailure, Message: e.ConnectionFailure()}
+	case client.ErrorSendFailure:
+		return &Error{Kind: SendFailure, Message: e.SendFailure()}
+	case client.ErrorReceiveFailure:
+		return &Error{Kind: ReceiveFailure, Message: e.ReceiveFailure()}
+	case client.ErrorProtocolError:
+		return &Error{Kind: ProtocolError, Message: e.ProtocolError()}
+	case client.ErrorClosed:
+		er := &Error{Kind: Closed, Message: "connection closed"}
+		if ci := e.Closed(); ci.IsSome() {
+			info := ci.Some()
+			er.CloseCode = info.Code
+			er.CloseReason = info.Reason
+			er.Message = fmt.Sprintf("connection closed: code %d %q", info.Code, info.Reason)
+		}
+		return er
+	default:
+		return &Error{Kind: Other, Message: e.Other()}
+	}
+}
+
+// ── Connection ────────────────────────────────────────────────────────────────
+
+// ConnectOpt configures a [Connect] call.
+type ConnectOpt func(*connectOpts)
+
+type connectOpts struct {
+	headers []witTypes.Tuple2[string, string]
+}
+
+// WithHeader adds a request header to the connection handshake.
+func WithHeader(key, value string) ConnectOpt {
+	return func(o *connectOpts) {
+		o.headers = append(o.headers, witTypes.Tuple2[string, string]{F0: key, F1: value})
+	}
+}
+
+// Conn is an open WebSocket connection.
+type Conn struct{ raw *client.WebsocketConnection }
+
+// Connect opens a WebSocket connection to url.
+func Connect(url string, opts ...ConnectOpt) (*Conn, error) {
+	var o connectOpts
+	for _, f := range opts {
+		f(&o)
+	}
+	headers := witTypes.None[[]witTypes.Tuple2[string, string]]()
+	if len(o.headers) > 0 {
+		headers = witTypes.Some(o.headers)
+	}
+	r := client.WebsocketConnectionConnect(url, headers)
+	if r.IsErr() {
+		return nil, wsError(r.Err())
+	}
+	return &Conn{raw: r.Ok()}, nil
+}
+
+// Send sends a frame.
+func (c *Conn) Send(m Message) error {
+	if r := c.raw.Send(m.toWit()); r.IsErr() {
+		return wsError(r.Err())
+	}
+	return nil
+}
+
+// SendText sends a text frame.
+func (c *Conn) SendText(s string) error { return c.Send(TextMessage(s)) }
+
+// SendBinary sends a binary frame.
+func (c *Conn) SendBinary(b []byte) error { return c.Send(BinaryMessage(b)) }
+
+// Receive blocks until a frame arrives (durably suspending the invocation).
+func (c *Conn) Receive() (Message, error) {
+	r := c.raw.Receive()
+	if r.IsErr() {
+		return Message{}, wsError(r.Err())
+	}
+	return messageFromWit(r.Ok()), nil
+}
+
+// ReceiveWithTimeout waits up to d for a frame. ok is false (nil error) if the
+// wait times out.
+func (c *Conn) ReceiveWithTimeout(d time.Duration) (msg Message, ok bool, err error) {
+	r := c.raw.ReceiveWithTimeout(uint64(d.Milliseconds()))
+	if r.IsErr() {
+		return Message{}, false, wsError(r.Err())
+	}
+	opt := r.Ok()
+	if opt.IsNone() {
+		return Message{}, false, nil
+	}
+	return messageFromWit(opt.Some()), true, nil
+}
+
+// Close closes the connection with the given code and reason.
+func (c *Conn) Close(code uint16, reason string) error {
+	if r := c.raw.Close(witTypes.Some(code), witTypes.Some(reason)); r.IsErr() {
+		return wsError(r.Err())
+	}
+	return nil
+}
diff --git a/sdks/go/golem/websocket/websocket_test.go b/sdks/go/golem/websocket/websocket_test.go
new file mode 100644
index 0000000000..ab8de697d8
--- /dev/null
+++ b/sdks/go/golem/websocket/websocket_test.go
@@ -0,0 +1,72 @@
+// Copyright 2024-2026 Golem Cloud
+//
+// 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 websocket
+
+import (
+	"testing"
+
+	client "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_websocket_client"
+	witTypes "go.bytecodealliance.org/pkg/wit/types"
+)
+
+// TestMessageRoundTrip — text/binary frames survive the toWit/fromWit conversion.
+func TestMessageRoundTrip(t *testing.T) {
+	txt := TextMessage("hello")
+	if !txt.IsText() || txt.IsBinary() {
+		t.Fatal("TextMessage should be text")
+	}
+	if got := messageFromWit(txt.toWit()); !got.IsText() || got.Text() != "hello" {
+		t.Fatalf("text round-trip = %+v", got)
+	}
+
+	bin := BinaryMessage([]byte{1, 2, 3})
+	if !bin.IsBinary() || bin.IsText() {
+		t.Fatal("BinaryMessage should be binary")
+	}
+	got := messageFromWit(bin.toWit())
+	if !got.IsBinary() || len(got.Bytes()) != 3 || got.Bytes()[2] != 3 {
+		t.Fatalf("binary round-trip = %+v", got)
+	}
+}
+
+// TestErrorMapping — each host error variant maps to the right kind/message.
+func TestErrorMapping(t *testing.T) {
+	cases := []struct {
+		raw  client.Error
+		kind ErrorKind
+		want string
+	}{
+		{client.MakeErrorConnectionFailure("refused"), ConnectionFailure, "refused"},
+		{client.MakeErrorSendFailure("send"), SendFailure, "send"},
+		{client.MakeErrorReceiveFailure("recv"), ReceiveFailure, "recv"},
+		{client.MakeErrorProtocolError("proto"), ProtocolError, "proto"},
+		{client.MakeErrorOther("other"), Other, "other"},
+	}
+	for _, c := range cases {
+		err := wsError(c.raw).(*Error)
+		if err.Kind != c.kind {
+			t.Fatalf("%v kind = %d, want %d", c.want, err.Kind, c.kind)
+		}
+		if err.Message != c.want {
+			t.Fatalf("message = %q, want %q", err.Message, c.want)
+		}
+	}
+
+	// Closed with a close frame carries the code/reason.
+	closed := wsError(client.MakeErrorClosed(witTypes.Some(client.CloseInfo{Code: 1001, Reason: "bye"}))).(*Error)
+	if !closed.IsClosed() || closed.CloseCode != 1001 || closed.CloseReason != "bye" {
+		t.Fatalf("closed = %+v", closed)
+	}
+}
diff --git a/sdks/go/golem/wit/deps/blobstore/blobstore.wit b/sdks/go/golem/wit/deps/blobstore/blobstore.wit
new file mode 100644
index 0000000000..cc52516a57
--- /dev/null
+++ b/sdks/go/golem/wit/deps/blobstore/blobstore.wit
@@ -0,0 +1,29 @@
+package wasi:blobstore;
+
+// wasi-cloud Blobstore service definition
+interface blobstore {
+  use container.{container};
+  use types.{error, container-name, object-id};
+
+  // creates a new empty container
+  create-container: func(name: container-name) -> result<container, error>;
+
+  // retrieves a container by name
+  get-container: func(name: container-name) -> result<container, error>;
+
+  // deletes a container and all objects within it
+  delete-container: func(name: container-name) -> result<_, error>;
+
+  // returns true if the container exists
+  container-exists: func(name: container-name) -> result<bool, error>;
+
+  // copies (duplicates) an object, to the same or a different container.
+  // returns an error if the target container does not exist.
+  // overwrites destination object if it already existed.
+  copy-object: func(src: object-id, dest: object-id) -> result<_, error>;
+
+  // moves or renames an object, to the same or a different container
+  // returns an error if the destination container does not exist.
+  // overwrites destination object if it already existed.
+  move-object: func(src:object-id, dest: object-id) -> result<_, error>;
+}
\ No newline at end of file
diff --git a/sdks/go/golem/wit/deps/blobstore/container.wit b/sdks/go/golem/wit/deps/blobstore/container.wit
new file mode 100644
index 0000000000..a814738526
--- /dev/null
+++ b/sdks/go/golem/wit/deps/blobstore/container.wit
@@ -0,0 +1,51 @@
+package wasi:blobstore;
+
+// a Container is a collection of objects
+interface container {
+  use types.{
+    container-metadata,
+    error,
+    incoming-value,
+    object-metadata,
+    object-name,
+    outgoing-value,
+  };
+
+  // this defines the `container` resource
+  resource container {
+    // returns container name
+    name: func() -> result<string, error>;
+
+    // returns container metadata
+    info: func() -> result<container-metadata, error>;
+
+    // retrieves an object or portion of an object, as a resource.
+    // Start and end offsets are inclusive.
+    // Once a data-blob resource has been created, the underlying bytes are held by the blobstore service for the lifetime
+    // of the data-blob resource, even if the object they came from is later deleted.
+    get-data: func(name: object-name, start: u64, end: u64) -> result<incoming-value, error>;
+
+    // creates or replaces an object with the data blob.
+    write-data: func(name: object-name, data: borrow<outgoing-value>) -> result<_, error>;
+
+    // returns list of objects in the container. Order is undefined.
+    list-objects: func() -> result<stream<object-name>, error>;
+
+    // deletes object.
+    // does not return error if object did not exist.
+    delete-object: func(name: object-name) -> result<_, error>;
+
+    // deletes multiple objects in the container
+    delete-objects: func(names: list<object-name>) -> result<_, error>;
+
+    // returns true if the object exists in this container
+    has-object: func(name: object-name) -> result<bool, error>;
+
+    // returns metadata for the object
+    object-info: func(name: object-name) -> result<object-metadata, error>;
+
+    // removes all objects within the container, leaving the container empty.
+    clear: func() -> result<_, error>;
+  }
+
+}
diff --git a/sdks/go/golem/wit/deps/blobstore/types.wit b/sdks/go/golem/wit/deps/blobstore/types.wit
new file mode 100644
index 0000000000..66454f8f9c
--- /dev/null
+++ b/sdks/go/golem/wit/deps/blobstore/types.wit
@@ -0,0 +1,70 @@
+package wasi:blobstore;
+
+// Types used by blobstore
+interface types {
+  // name of a container, a collection of objects.
+  // The container name may be any valid UTF-8 string.
+  type container-name = string;
+
+  // name of an object within a container
+  // The object name may be any valid UTF-8 string.
+  type object-name = string;
+
+  // TODO: define timestamp to include seconds since
+  // Unix epoch and nanoseconds
+  // https://github.com/WebAssembly/wasi-blob-store/issues/7
+  type timestamp = u64;
+
+  // size of an object, in bytes
+  type object-size = u64;
+
+  type error = string;
+
+  // information about a container
+  record container-metadata {
+    // the container's name
+    name: container-name,
+    // date and time container was created
+    created-at: timestamp,
+  }
+
+  // information about an object
+  record object-metadata {
+    // the object's name
+    name: object-name,
+    // the object's parent container
+    container: container-name,
+    // date and time the object was created
+    created-at: timestamp,
+    // size of the object, in bytes
+    size: object-size,
+  }
+
+  // identifier for an object that includes its container name
+  record object-id {
+    container: container-name,
+    object: object-name
+  }
+
+  /// A data blob value. The value can be of any type that can be represented
+  /// in a byte array.
+  // Soon: switch to `resource value { ... }`
+  resource outgoing-value {
+    new-outgoing-value: static func() -> outgoing-value;
+    outgoing-value-write-body: func(data: stream<u8>) -> result;
+  }
+
+  /// A incoming-value is a wrapper around a value.
+  ///
+  /// The incoming-value provides two ways to consume the value:
+  /// 1. `incoming-value-consume-sync` consumes the value synchronously and returns the
+  ///    value as a list of bytes.
+  /// 2. `incoming-value-consume-async` consumes the value asynchronously and returns the
+  ///    value as a `stream<u8>`.
+  // Soon: switch to `resource incoming-value { ... }`
+  resource incoming-value {
+      incoming-value-consume-sync: func() -> result<list<u8>, error>;
+      incoming-value-consume-async: func() -> result<stream<u8>, error>;
+      size: func() -> u64;
+  }
+}
diff --git a/sdks/go/golem/wit/deps/blobstore/world.wit b/sdks/go/golem/wit/deps/blobstore/world.wit
new file mode 100644
index 0000000000..4391d68b87
--- /dev/null
+++ b/sdks/go/golem/wit/deps/blobstore/world.wit
@@ -0,0 +1,5 @@
+package wasi:blobstore;
+
+world blob-store {
+	import blobstore;
+}
\ No newline at end of file
diff --git a/sdks/go/golem/wit/deps/cli-0.2.6/cli.wit b/sdks/go/golem/wit/deps/cli-0.2.6/cli.wit
new file mode 100644
index 0000000000..d7a3ca4d2c
--- /dev/null
+++ b/sdks/go/golem/wit/deps/cli-0.2.6/cli.wit
@@ -0,0 +1,261 @@
+package wasi:cli@0.2.6;
+
+@since(version = 0.2.0)
+interface environment {
+  /// Get the POSIX-style environment variables.
+  ///
+  /// Each environment variable is provided as a pair of string variable names
+  /// and string value.
+  ///
+  /// Morally, these are a value import, but until value imports are available
+  /// in the component model, this import function should return the same
+  /// values each time it is called.
+  @since(version = 0.2.0)
+  get-environment: func() -> list<tuple<string, string>>;
+
+  /// Get the POSIX-style arguments to the program.
+  @since(version = 0.2.0)
+  get-arguments: func() -> list<string>;
+
+  /// Return a path that programs should use as their initial current working
+  /// directory, interpreting `.` as shorthand for this.
+  @since(version = 0.2.0)
+  initial-cwd: func() -> option<string>;
+}
+
+@since(version = 0.2.0)
+interface exit {
+  /// Exit the current instance and any linked instances.
+  @since(version = 0.2.0)
+  exit: func(status: result);
+
+  /// Exit the current instance and any linked instances, reporting the
+  /// specified status code to the host.
+  ///
+  /// The meaning of the code depends on the context, with 0 usually meaning
+  /// "success", and other values indicating various types of failure.
+  ///
+  /// This function does not return; the effect is analogous to a trap, but
+  /// without the connotation that something bad has happened.
+  @unstable(feature = cli-exit-with-code)
+  exit-with-code: func(status-code: u8);
+}
+
+@since(version = 0.2.0)
+interface run {
+  /// Run the program.
+  @since(version = 0.2.0)
+  run: func() -> result;
+}
+
+@since(version = 0.2.0)
+interface stdin {
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.6.{input-stream};
+
+  @since(version = 0.2.0)
+  get-stdin: func() -> input-stream;
+}
+
+@since(version = 0.2.0)
+interface stdout {
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.6.{output-stream};
+
+  @since(version = 0.2.0)
+  get-stdout: func() -> output-stream;
+}
+
+@since(version = 0.2.0)
+interface stderr {
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.6.{output-stream};
+
+  @since(version = 0.2.0)
+  get-stderr: func() -> output-stream;
+}
+
+/// Terminal input.
+///
+/// In the future, this may include functions for disabling echoing,
+/// disabling input buffering so that keyboard events are sent through
+/// immediately, querying supported features, and so on.
+@since(version = 0.2.0)
+interface terminal-input {
+  /// The input side of a terminal.
+  @since(version = 0.2.0)
+  resource terminal-input;
+}
+
+/// Terminal output.
+///
+/// In the future, this may include functions for querying the terminal
+/// size, being notified of terminal size changes, querying supported
+/// features, and so on.
+@since(version = 0.2.0)
+interface terminal-output {
+  /// The output side of a terminal.
+  @since(version = 0.2.0)
+  resource terminal-output;
+}
+
+/// An interface providing an optional `terminal-input` for stdin as a
+/// link-time authority.
+@since(version = 0.2.0)
+interface terminal-stdin {
+  @since(version = 0.2.0)
+  use terminal-input.{terminal-input};
+
+  /// If stdin is connected to a terminal, return a `terminal-input` handle
+  /// allowing further interaction with it.
+  @since(version = 0.2.0)
+  get-terminal-stdin: func() -> option<terminal-input>;
+}
+
+/// An interface providing an optional `terminal-output` for stdout as a
+/// link-time authority.
+@since(version = 0.2.0)
+interface terminal-stdout {
+  @since(version = 0.2.0)
+  use terminal-output.{terminal-output};
+
+  /// If stdout is connected to a terminal, return a `terminal-output` handle
+  /// allowing further interaction with it.
+  @since(version = 0.2.0)
+  get-terminal-stdout: func() -> option<terminal-output>;
+}
+
+/// An interface providing an optional `terminal-output` for stderr as a
+/// link-time authority.
+@since(version = 0.2.0)
+interface terminal-stderr {
+  @since(version = 0.2.0)
+  use terminal-output.{terminal-output};
+
+  /// If stderr is connected to a terminal, return a `terminal-output` handle
+  /// allowing further interaction with it.
+  @since(version = 0.2.0)
+  get-terminal-stderr: func() -> option<terminal-output>;
+}
+
+@since(version = 0.2.0)
+world imports {
+  @since(version = 0.2.0)
+  import environment;
+  @since(version = 0.2.0)
+  import exit;
+  @since(version = 0.2.0)
+  import wasi:io/error@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:io/poll@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:io/streams@0.2.6;
+  @since(version = 0.2.0)
+  import stdin;
+  @since(version = 0.2.0)
+  import stdout;
+  @since(version = 0.2.0)
+  import stderr;
+  @since(version = 0.2.0)
+  import terminal-input;
+  @since(version = 0.2.0)
+  import terminal-output;
+  @since(version = 0.2.0)
+  import terminal-stdin;
+  @since(version = 0.2.0)
+  import terminal-stdout;
+  @since(version = 0.2.0)
+  import terminal-stderr;
+  @since(version = 0.2.0)
+  import wasi:clocks/monotonic-clock@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:clocks/wall-clock@0.2.6;
+  @unstable(feature = clocks-timezone)
+  import wasi:clocks/timezone@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:filesystem/types@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:filesystem/preopens@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:sockets/network@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:sockets/instance-network@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:sockets/udp@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:sockets/udp-create-socket@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:sockets/tcp@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:sockets/tcp-create-socket@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:sockets/ip-name-lookup@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:random/random@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:random/insecure@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:random/insecure-seed@0.2.6;
+}
+@since(version = 0.2.0)
+world command {
+  @since(version = 0.2.0)
+  import environment;
+  @since(version = 0.2.0)
+  import exit;
+  @since(version = 0.2.0)
+  import wasi:io/error@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:io/poll@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:io/streams@0.2.6;
+  @since(version = 0.2.0)
+  import stdin;
+  @since(version = 0.2.0)
+  import stdout;
+  @since(version = 0.2.0)
+  import stderr;
+  @since(version = 0.2.0)
+  import terminal-input;
+  @since(version = 0.2.0)
+  import terminal-output;
+  @since(version = 0.2.0)
+  import terminal-stdin;
+  @since(version = 0.2.0)
+  import terminal-stdout;
+  @since(version = 0.2.0)
+  import terminal-stderr;
+  @since(version = 0.2.0)
+  import wasi:clocks/monotonic-clock@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:clocks/wall-clock@0.2.6;
+  @unstable(feature = clocks-timezone)
+  import wasi:clocks/timezone@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:filesystem/types@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:filesystem/preopens@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:sockets/network@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:sockets/instance-network@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:sockets/udp@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:sockets/udp-create-socket@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:sockets/tcp@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:sockets/tcp-create-socket@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:sockets/ip-name-lookup@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:random/random@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:random/insecure@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:random/insecure-seed@0.2.6;
+
+  @since(version = 0.2.0)
+  export run;
+}
diff --git a/sdks/go/golem/wit/deps/cli/cli.wit b/sdks/go/golem/wit/deps/cli/cli.wit
new file mode 100644
index 0000000000..7aae56c17e
--- /dev/null
+++ b/sdks/go/golem/wit/deps/cli/cli.wit
@@ -0,0 +1,256 @@
+package wasi:cli@0.3.0;
+
+@since(version = 0.3.0)
+interface environment {
+  /// Get the POSIX-style environment variables.
+  ///
+  /// Each environment variable is provided as a pair of string variable names
+  /// and string value.
+  ///
+  /// Morally, these are a value import, but until value imports are available
+  /// in the component model, this import function should return the same
+  /// values each time it is called.
+  @since(version = 0.3.0)
+  get-environment: func() -> list<tuple<string, string>>;
+
+  /// Get the POSIX-style arguments to the program.
+  @since(version = 0.3.0)
+  get-arguments: func() -> list<string>;
+
+  /// Return a path that programs should use as their initial current working
+  /// directory, interpreting `.` as shorthand for this.
+  @since(version = 0.3.0)
+  get-initial-cwd: func() -> option<string>;
+}
+
+@since(version = 0.3.0)
+interface exit {
+  /// Exit the current instance and any linked instances.
+  @since(version = 0.3.0)
+  exit: func(status: result);
+
+  /// Exit the current instance and any linked instances, reporting the
+  /// specified status code to the host.
+  ///
+  /// The meaning of the code depends on the context, with 0 usually meaning
+  /// "success", and other values indicating various types of failure.
+  ///
+  /// This function does not return; the effect is analogous to a trap, but
+  /// without the connotation that something bad has happened.
+  @since(version = 0.3.0)
+  exit-with-code: func(status-code: u8);
+}
+
+@since(version = 0.3.0)
+interface run {
+  /// Run the program.
+  @since(version = 0.3.0)
+  run: async func() -> result;
+}
+
+@since(version = 0.3.0)
+interface types {
+  @since(version = 0.3.0)
+  enum error-code {
+    /// Input/output error
+    io,
+    /// Invalid or incomplete multibyte or wide character
+    illegal-byte-sequence,
+    /// Broken pipe
+    pipe,
+  }
+}
+
+@since(version = 0.3.0)
+interface stdin {
+  use types.{error-code};
+
+  /// Return a stream for reading from stdin.
+  ///
+  /// This function returns a stream which provides data read from stdin,
+  /// and a future to signal read results.
+  ///
+  /// If the stream's readable end is dropped the future will resolve to success.
+  ///
+  /// If the stream's writable end is dropped the future will either resolve to
+  /// success if stdin was closed by the writer or to an error-code if reading
+  /// failed for some other reason.
+  ///
+  /// Multiple streams may be active at the same time. The behavior of concurrent
+  /// reads is implementation-specific.
+  @since(version = 0.3.0)
+  read-via-stream: func() -> tuple<stream<u8>, future<result<_, error-code>>>;
+}
+
+@since(version = 0.3.0)
+interface stdout {
+  use types.{error-code};
+
+  /// Write the given stream to stdout.
+  ///
+  /// If the stream's writable end is dropped this function will either return
+  /// success once the entire contents of the stream have been written or an
+  /// error-code representing a failure.
+  ///
+  /// Otherwise if there is an error the readable end of the stream will be
+  /// dropped and this function will return an error-code.
+  @since(version = 0.3.0)
+  write-via-stream: func(data: stream<u8>) -> future<result<_, error-code>>;
+}
+
+@since(version = 0.3.0)
+interface stderr {
+  use types.{error-code};
+
+  /// Write the given stream to stderr.
+  ///
+  /// If the stream's writable end is dropped this function will either return
+  /// success once the entire contents of the stream have been written or an
+  /// error-code representing a failure.
+  ///
+  /// Otherwise if there is an error the readable end of the stream will be
+  /// dropped and this function will return an error-code.
+  @since(version = 0.3.0)
+  write-via-stream: func(data: stream<u8>) -> future<result<_, error-code>>;
+}
+
+/// Terminal input.
+///
+/// In the future, this may include functions for disabling echoing,
+/// disabling input buffering so that keyboard events are sent through
+/// immediately, querying supported features, and so on.
+@since(version = 0.3.0)
+interface terminal-input {
+  /// The input side of a terminal.
+  @since(version = 0.3.0)
+  resource terminal-input;
+}
+
+/// Terminal output.
+///
+/// In the future, this may include functions for querying the terminal
+/// size, being notified of terminal size changes, querying supported
+/// features, and so on.
+@since(version = 0.3.0)
+interface terminal-output {
+  /// The output side of a terminal.
+  @since(version = 0.3.0)
+  resource terminal-output;
+}
+
+/// An interface providing an optional `terminal-input` for stdin as a
+/// link-time authority.
+@since(version = 0.3.0)
+interface terminal-stdin {
+  @since(version = 0.3.0)
+  use terminal-input.{terminal-input};
+
+  /// If stdin is connected to a terminal, return a `terminal-input` handle
+  /// allowing further interaction with it.
+  @since(version = 0.3.0)
+  get-terminal-stdin: func() -> option<terminal-input>;
+}
+
+/// An interface providing an optional `terminal-output` for stdout as a
+/// link-time authority.
+@since(version = 0.3.0)
+interface terminal-stdout {
+  @since(version = 0.3.0)
+  use terminal-output.{terminal-output};
+
+  /// If stdout is connected to a terminal, return a `terminal-output` handle
+  /// allowing further interaction with it.
+  @since(version = 0.3.0)
+  get-terminal-stdout: func() -> option<terminal-output>;
+}
+
+/// An interface providing an optional `terminal-output` for stderr as a
+/// link-time authority.
+@since(version = 0.3.0)
+interface terminal-stderr {
+  @since(version = 0.3.0)
+  use terminal-output.{terminal-output};
+
+  /// If stderr is connected to a terminal, return a `terminal-output` handle
+  /// allowing further interaction with it.
+  @since(version = 0.3.0)
+  get-terminal-stderr: func() -> option<terminal-output>;
+}
+
+@since(version = 0.3.0)
+world imports {
+  @since(version = 0.3.0)
+  import environment;
+  @since(version = 0.3.0)
+  import exit;
+  @since(version = 0.3.0)
+  import types;
+  @since(version = 0.3.0)
+  import stdin;
+  @since(version = 0.3.0)
+  import stdout;
+  @since(version = 0.3.0)
+  import stderr;
+  @since(version = 0.3.0)
+  import terminal-input;
+  @since(version = 0.3.0)
+  import terminal-output;
+  @since(version = 0.3.0)
+  import terminal-stdin;
+  @since(version = 0.3.0)
+  import terminal-stdout;
+  @since(version = 0.3.0)
+  import terminal-stderr;
+  import wasi:clocks/types@0.3.0;
+  import wasi:clocks/monotonic-clock@0.3.0;
+  import wasi:clocks/system-clock@0.3.0;
+  @unstable(feature = clocks-timezone)
+  import wasi:clocks/timezone@0.3.0;
+  import wasi:filesystem/types@0.3.0;
+  import wasi:filesystem/preopens@0.3.0;
+  import wasi:sockets/types@0.3.0;
+  import wasi:sockets/ip-name-lookup@0.3.0;
+  import wasi:random/random@0.3.0;
+  import wasi:random/insecure@0.3.0;
+  import wasi:random/insecure-seed@0.3.0;
+}
+@since(version = 0.3.0)
+world command {
+  @since(version = 0.3.0)
+  import environment;
+  @since(version = 0.3.0)
+  import exit;
+  @since(version = 0.3.0)
+  import types;
+  @since(version = 0.3.0)
+  import stdin;
+  @since(version = 0.3.0)
+  import stdout;
+  @since(version = 0.3.0)
+  import stderr;
+  @since(version = 0.3.0)
+  import terminal-input;
+  @since(version = 0.3.0)
+  import terminal-output;
+  @since(version = 0.3.0)
+  import terminal-stdin;
+  @since(version = 0.3.0)
+  import terminal-stdout;
+  @since(version = 0.3.0)
+  import terminal-stderr;
+  import wasi:clocks/types@0.3.0;
+  import wasi:clocks/monotonic-clock@0.3.0;
+  import wasi:clocks/system-clock@0.3.0;
+  @unstable(feature = clocks-timezone)
+  import wasi:clocks/timezone@0.3.0;
+  import wasi:filesystem/types@0.3.0;
+  import wasi:filesystem/preopens@0.3.0;
+  import wasi:sockets/types@0.3.0;
+  import wasi:sockets/ip-name-lookup@0.3.0;
+  import wasi:random/random@0.3.0;
+  import wasi:random/insecure@0.3.0;
+  import wasi:random/insecure-seed@0.3.0;
+
+  @since(version = 0.3.0)
+  export run;
+}
diff --git a/sdks/go/golem/wit/deps/clocks-0.2.6/clocks.wit b/sdks/go/golem/wit/deps/clocks-0.2.6/clocks.wit
new file mode 100644
index 0000000000..d638f1a40f
--- /dev/null
+++ b/sdks/go/golem/wit/deps/clocks-0.2.6/clocks.wit
@@ -0,0 +1,157 @@
+package wasi:clocks@0.2.6;
+
+/// WASI Monotonic Clock is a clock API intended to let users measure elapsed
+/// time.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+///
+/// A monotonic clock is a clock which has an unspecified initial value, and
+/// successive reads of the clock will produce non-decreasing values.
+@since(version = 0.2.0)
+interface monotonic-clock {
+  @since(version = 0.2.0)
+  use wasi:io/poll@0.2.6.{pollable};
+
+  /// An instant in time, in nanoseconds. An instant is relative to an
+  /// unspecified initial value, and can only be compared to instances from
+  /// the same monotonic-clock.
+  @since(version = 0.2.0)
+  type instant = u64;
+
+  /// A duration of time, in nanoseconds.
+  @since(version = 0.2.0)
+  type duration = u64;
+
+  /// Read the current value of the clock.
+  ///
+  /// The clock is monotonic, therefore calling this function repeatedly will
+  /// produce a sequence of non-decreasing values.
+  @since(version = 0.2.0)
+  now: func() -> instant;
+
+  /// Query the resolution of the clock. Returns the duration of time
+  /// corresponding to a clock tick.
+  @since(version = 0.2.0)
+  resolution: func() -> duration;
+
+  /// Create a `pollable` which will resolve once the specified instant
+  /// has occurred.
+  @since(version = 0.2.0)
+  subscribe-instant: func(when: instant) -> pollable;
+
+  /// Create a `pollable` that will resolve after the specified duration has
+  /// elapsed from the time this function is invoked.
+  @since(version = 0.2.0)
+  subscribe-duration: func(when: duration) -> pollable;
+}
+
+/// WASI Wall Clock is a clock API intended to let users query the current
+/// time. The name "wall" makes an analogy to a "clock on the wall", which
+/// is not necessarily monotonic as it may be reset.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+///
+/// A wall clock is a clock which measures the date and time according to
+/// some external reference.
+///
+/// External references may be reset, so this clock is not necessarily
+/// monotonic, making it unsuitable for measuring elapsed time.
+///
+/// It is intended for reporting the current date and time for humans.
+@since(version = 0.2.0)
+interface wall-clock {
+  /// A time and date in seconds plus nanoseconds.
+  @since(version = 0.2.0)
+  record datetime {
+    seconds: u64,
+    nanoseconds: u32,
+  }
+
+  /// Read the current value of the clock.
+  ///
+  /// This clock is not monotonic, therefore calling this function repeatedly
+  /// will not necessarily produce a sequence of non-decreasing values.
+  ///
+  /// The returned timestamps represent the number of seconds since
+  /// 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch],
+  /// also known as [Unix Time].
+  ///
+  /// The nanoseconds field of the output is always less than 1000000000.
+  ///
+  /// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
+  /// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
+  @since(version = 0.2.0)
+  now: func() -> datetime;
+
+  /// Query the resolution of the clock.
+  ///
+  /// The nanoseconds field of the output is always less than 1000000000.
+  @since(version = 0.2.0)
+  resolution: func() -> datetime;
+}
+
+@unstable(feature = clocks-timezone)
+interface timezone {
+  @unstable(feature = clocks-timezone)
+  use wall-clock.{datetime};
+
+  /// Information useful for displaying the timezone of a specific `datetime`.
+  ///
+  /// This information may vary within a single `timezone` to reflect daylight
+  /// saving time adjustments.
+  @unstable(feature = clocks-timezone)
+  record timezone-display {
+    /// The number of seconds difference between UTC time and the local
+    /// time of the timezone.
+    ///
+    /// The returned value will always be less than 86400 which is the
+    /// number of seconds in a day (24*60*60).
+    ///
+    /// In implementations that do not expose an actual time zone, this
+    /// should return 0.
+    utc-offset: s32,
+    /// The abbreviated name of the timezone to display to a user. The name
+    /// `UTC` indicates Coordinated Universal Time. Otherwise, this should
+    /// reference local standards for the name of the time zone.
+    ///
+    /// In implementations that do not expose an actual time zone, this
+    /// should be the string `UTC`.
+    ///
+    /// In time zones that do not have an applicable name, a formatted
+    /// representation of the UTC offset may be returned, such as `-04:00`.
+    name: string,
+    /// Whether daylight saving time is active.
+    ///
+    /// In implementations that do not expose an actual time zone, this
+    /// should return false.
+    in-daylight-saving-time: bool,
+  }
+
+  /// Return information needed to display the given `datetime`. This includes
+  /// the UTC offset, the time zone name, and a flag indicating whether
+  /// daylight saving time is active.
+  ///
+  /// If the timezone cannot be determined for the given `datetime`, return a
+  /// `timezone-display` for `UTC` with a `utc-offset` of 0 and no daylight
+  /// saving time.
+  @unstable(feature = clocks-timezone)
+  display: func(when: datetime) -> timezone-display;
+
+  /// The same as `display`, but only return the UTC offset.
+  @unstable(feature = clocks-timezone)
+  utc-offset: func(when: datetime) -> s32;
+}
+
+@since(version = 0.2.0)
+world imports {
+  @since(version = 0.2.0)
+  import wasi:io/poll@0.2.6;
+  @since(version = 0.2.0)
+  import monotonic-clock;
+  @since(version = 0.2.0)
+  import wall-clock;
+  @unstable(feature = clocks-timezone)
+  import timezone;
+}
diff --git a/sdks/go/golem/wit/deps/clocks/clocks.wit b/sdks/go/golem/wit/deps/clocks/clocks.wit
new file mode 100644
index 0000000000..d8b8cfe4e3
--- /dev/null
+++ b/sdks/go/golem/wit/deps/clocks/clocks.wit
@@ -0,0 +1,161 @@
+package wasi:clocks@0.3.0;
+
+/// This interface common types used throughout wasi:clocks.
+@since(version = 0.3.0)
+interface types {
+  /// A duration of time, in nanoseconds.
+  @since(version = 0.3.0)
+  type duration = u64;
+}
+
+/// WASI Monotonic Clock is a clock API intended to let users measure elapsed
+/// time.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+///
+/// A monotonic clock is a clock which has an unspecified initial value, and
+/// successive reads of the clock will produce non-decreasing values.
+@since(version = 0.3.0)
+interface monotonic-clock {
+  use types.{duration};
+
+  /// A mark on a monotonic clock is a number of nanoseconds since an
+  /// unspecified initial value, and can only be compared to instances from
+  /// the same monotonic-clock.
+  @since(version = 0.3.0)
+  type mark = u64;
+
+  /// Read the current value of the clock.
+  ///
+  /// The clock is monotonic, therefore calling this function repeatedly will
+  /// produce a sequence of non-decreasing values.
+  ///
+  /// For completeness, this function traps if it's not possible to represent
+  /// the value of the clock in a `mark`. Consequently, implementations
+  /// should ensure that the starting time is low enough to avoid the
+  /// possibility of overflow in practice.
+  @since(version = 0.3.0)
+  now: func() -> mark;
+
+  /// Query the resolution of the clock. Returns the duration of time
+  /// corresponding to a clock tick.
+  @since(version = 0.3.0)
+  get-resolution: func() -> duration;
+
+  /// Wait until the specified mark has occurred.
+  @since(version = 0.3.0)
+  wait-until: async func(when: mark);
+
+  /// Wait for the specified duration to elapse.
+  @since(version = 0.3.0)
+  wait-for: async func(how-long: duration);
+}
+
+/// WASI System Clock is a clock API intended to let users query the current
+/// time. The clock is not necessarily monotonic as it may be reset.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+///
+/// External references may be reset, so this clock is not necessarily
+/// monotonic, making it unsuitable for measuring elapsed time.
+///
+/// It is intended for reporting the current date and time for humans.
+@since(version = 0.3.0)
+interface system-clock {
+  use types.{duration};
+
+  /// An "instant", or "exact time", is a point in time without regard to any
+  /// time zone: just the time since a particular external reference point,
+  /// often called an "epoch".
+  ///
+  /// Here, the epoch is 1970-01-01T00:00:00Z, also known as
+  /// [POSIX's Seconds Since the Epoch], also known as [Unix Time].
+  ///
+  /// Note that even if the seconds field is negative, incrementing
+  /// nanoseconds always represents moving forwards in time.
+  /// For example, `{ -1 seconds, 999999999 nanoseconds }` represents the
+  /// instant one nanosecond before the epoch.
+  /// For more on various different ways to represent time, see
+  /// https://tc39.es/proposal-temporal/docs/timezone.html
+  ///
+  /// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
+  /// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
+  @since(version = 0.3.0)
+  record instant {
+    seconds: s64,
+    nanoseconds: u32,
+  }
+
+  /// Read the current value of the clock.
+  ///
+  /// This clock is not monotonic, therefore calling this function repeatedly
+  /// will not necessarily produce a sequence of non-decreasing values.
+  ///
+  /// The nanoseconds field of the output is always less than 1000000000.
+  @since(version = 0.3.0)
+  now: func() -> instant;
+
+  /// Query the resolution of the clock. Returns the smallest duration of time
+  /// that the implementation permits distinguishing.
+  @since(version = 0.3.0)
+  get-resolution: func() -> duration;
+}
+
+@unstable(feature = clocks-timezone)
+interface timezone {
+  @unstable(feature = clocks-timezone)
+  use system-clock.{instant};
+
+  /// Return the IANA identifier of the currently configured timezone. This
+  /// should be an identifier from the IANA Time Zone Database.
+  ///
+  /// For displaying to a user, the identifier should be converted into a
+  /// localized name by means of an internationalization API.
+  ///
+  /// If the implementation does not expose an actual timezone, or is unable
+  /// to provide mappings from times to deltas between the configured timezone
+  /// and UTC, or determining the current timezone fails, or the timezone does
+  /// not have an IANA identifier, this returns nothing.
+  @unstable(feature = clocks-timezone)
+  iana-id: func() -> option<string>;
+
+  /// The number of nanoseconds difference between UTC time and the local
+  /// time of the currently configured timezone, at the exact time of
+  /// `instant`.
+  ///
+  /// The magnitude of the returned value will always be less than
+  /// 86,400,000,000,000 which is the number of nanoseconds in a day
+  /// (24*60*60*1e9).
+  ///
+  /// If the implementation does not expose an actual timezone, or is unable
+  /// to provide mappings from times to deltas between the configured timezone
+  /// and UTC, or determining the current timezone fails, this returns
+  /// nothing.
+  @unstable(feature = clocks-timezone)
+  utc-offset: func(when: instant) -> option<s64>;
+
+  /// Returns a string that is suitable to assist humans in debugging whether
+  /// any timezone is available, and if so, which. This may be the same string
+  /// as `iana-id`, or a formatted representation of the UTC offset such as
+  /// `-04:00`, or something else.
+  ///
+  /// WARNING: The returned string should not be consumed mechanically! It may
+  /// change across platforms, hosts, or other implementation details. Parsing
+  /// this string is a major platform-compatibility hazard.
+  @unstable(feature = clocks-timezone)
+  to-debug-string: func() -> string;
+}
+
+@since(version = 0.3.0)
+world imports {
+  @since(version = 0.3.0)
+  import types;
+  @since(version = 0.3.0)
+  import monotonic-clock;
+  @since(version = 0.3.0)
+  import system-clock;
+  @unstable(feature = clocks-timezone)
+  import timezone;
+}
diff --git a/sdks/go/golem/wit/deps/config/store.wit b/sdks/go/golem/wit/deps/config/store.wit
new file mode 100644
index 0000000000..794379a754
--- /dev/null
+++ b/sdks/go/golem/wit/deps/config/store.wit
@@ -0,0 +1,30 @@
+interface store {
+    /// An error type that encapsulates the different errors that can occur fetching configuration values.
+    variant error {
+        /// This indicates an error from an "upstream" config source. 
+        /// As this could be almost _anything_ (such as Vault, Kubernetes ConfigMaps, KeyValue buckets, etc), 
+        /// the error message is a string.
+        upstream(string),
+        /// This indicates an error from an I/O operation. 
+        /// As this could be almost _anything_ (such as a file read, network connection, etc), 
+        /// the error message is a string. 
+        /// Depending on how this ends up being consumed, 
+        /// we may consider moving this to use the `wasi:io/error` type instead. 
+        /// For simplicity right now in supporting multiple implementations, it is being left as a string.
+        io(string),
+    }
+
+    /// Gets a configuration value of type `string` associated with the `key`. 
+    /// 
+    /// The value is returned as an `option<string>`. If the key is not found,
+    /// `Ok(none)` is returned. If an error occurs, an `Err(error)` is returned.
+    get: func(
+        /// A string key to fetch
+        key: string
+    ) -> result<option<string>, error>;
+
+    /// Gets a list of configuration key-value pairs of type `string`.
+    /// 
+    /// If an error occurs, an `Err(error)` is returned.
+    get-all: func() -> result<list<tuple<string, string>>, error>;
+}
diff --git a/sdks/go/golem/wit/deps/config/world.wit b/sdks/go/golem/wit/deps/config/world.wit
new file mode 100644
index 0000000000..f92f080a57
--- /dev/null
+++ b/sdks/go/golem/wit/deps/config/world.wit
@@ -0,0 +1,6 @@
+package wasi:config@0.2.0-draft;
+
+world imports {
+    /// The interface for wasi:config/store
+    import store;
+}
\ No newline at end of file
diff --git a/sdks/go/golem/wit/deps/filesystem-0.2.6/filesystem.wit b/sdks/go/golem/wit/deps/filesystem-0.2.6/filesystem.wit
new file mode 100644
index 0000000000..9f4a8288b4
--- /dev/null
+++ b/sdks/go/golem/wit/deps/filesystem-0.2.6/filesystem.wit
@@ -0,0 +1,587 @@
+package wasi:filesystem@0.2.6;
+
+/// WASI filesystem is a filesystem API primarily intended to let users run WASI
+/// programs that access their files on their existing filesystems, without
+/// significant overhead.
+///
+/// It is intended to be roughly portable between Unix-family platforms and
+/// Windows, though it does not hide many of the major differences.
+///
+/// Paths are passed as interface-type `string`s, meaning they must consist of
+/// a sequence of Unicode Scalar Values (USVs). Some filesystems may contain
+/// paths which are not accessible by this API.
+///
+/// The directory separator in WASI is always the forward-slash (`/`).
+///
+/// All paths in WASI are relative paths, and are interpreted relative to a
+/// `descriptor` referring to a base directory. If a `path` argument to any WASI
+/// function starts with `/`, or if any step of resolving a `path`, including
+/// `..` and symbolic link steps, reaches a directory outside of the base
+/// directory, or reaches a symlink to an absolute or rooted path in the
+/// underlying filesystem, the function fails with `error-code::not-permitted`.
+///
+/// For more information about WASI path resolution and sandboxing, see
+/// [WASI filesystem path resolution].
+///
+/// [WASI filesystem path resolution]: https://github.com/WebAssembly/wasi-filesystem/blob/main/path-resolution.md
+@since(version = 0.2.0)
+interface types {
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.6.{input-stream, output-stream, error};
+  @since(version = 0.2.0)
+  use wasi:clocks/wall-clock@0.2.6.{datetime};
+
+  /// File size or length of a region within a file.
+  @since(version = 0.2.0)
+  type filesize = u64;
+
+  /// The type of a filesystem object referenced by a descriptor.
+  ///
+  /// Note: This was called `filetype` in earlier versions of WASI.
+  @since(version = 0.2.0)
+  enum descriptor-type {
+    /// The type of the descriptor or file is unknown or is different from
+    /// any of the other types specified.
+    unknown,
+    /// The descriptor refers to a block device inode.
+    block-device,
+    /// The descriptor refers to a character device inode.
+    character-device,
+    /// The descriptor refers to a directory inode.
+    directory,
+    /// The descriptor refers to a named pipe.
+    fifo,
+    /// The file refers to a symbolic link inode.
+    symbolic-link,
+    /// The descriptor refers to a regular file inode.
+    regular-file,
+    /// The descriptor refers to a socket.
+    socket,
+  }
+
+  /// Descriptor flags.
+  ///
+  /// Note: This was called `fdflags` in earlier versions of WASI.
+  @since(version = 0.2.0)
+  flags descriptor-flags {
+    /// Read mode: Data can be read.
+    read,
+    /// Write mode: Data can be written to.
+    write,
+    /// Request that writes be performed according to synchronized I/O file
+    /// integrity completion. The data stored in the file and the file's
+    /// metadata are synchronized. This is similar to `O_SYNC` in POSIX.
+    ///
+    /// The precise semantics of this operation have not yet been defined for
+    /// WASI. At this time, it should be interpreted as a request, and not a
+    /// requirement.
+    file-integrity-sync,
+    /// Request that writes be performed according to synchronized I/O data
+    /// integrity completion. Only the data stored in the file is
+    /// synchronized. This is similar to `O_DSYNC` in POSIX.
+    ///
+    /// The precise semantics of this operation have not yet been defined for
+    /// WASI. At this time, it should be interpreted as a request, and not a
+    /// requirement.
+    data-integrity-sync,
+    /// Requests that reads be performed at the same level of integrity
+    /// requested for writes. This is similar to `O_RSYNC` in POSIX.
+    ///
+    /// The precise semantics of this operation have not yet been defined for
+    /// WASI. At this time, it should be interpreted as a request, and not a
+    /// requirement.
+    requested-write-sync,
+    /// Mutating directories mode: Directory contents may be mutated.
+    ///
+    /// When this flag is unset on a descriptor, operations using the
+    /// descriptor which would create, rename, delete, modify the data or
+    /// metadata of filesystem objects, or obtain another handle which
+    /// would permit any of those, shall fail with `error-code::read-only` if
+    /// they would otherwise succeed.
+    ///
+    /// This may only be set on directories.
+    mutate-directory,
+  }
+
+  /// Flags determining the method of how paths are resolved.
+  @since(version = 0.2.0)
+  flags path-flags {
+    /// As long as the resolved path corresponds to a symbolic link, it is
+    /// expanded.
+    symlink-follow,
+  }
+
+  /// Open flags used by `open-at`.
+  @since(version = 0.2.0)
+  flags open-flags {
+    /// Create file if it does not exist, similar to `O_CREAT` in POSIX.
+    create,
+    /// Fail if not a directory, similar to `O_DIRECTORY` in POSIX.
+    directory,
+    /// Fail if file already exists, similar to `O_EXCL` in POSIX.
+    exclusive,
+    /// Truncate file to size 0, similar to `O_TRUNC` in POSIX.
+    truncate,
+  }
+
+  /// Number of hard links to an inode.
+  @since(version = 0.2.0)
+  type link-count = u64;
+
+  /// File attributes.
+  ///
+  /// Note: This was called `filestat` in earlier versions of WASI.
+  @since(version = 0.2.0)
+  record descriptor-stat {
+    /// File type.
+    %type: descriptor-type,
+    /// Number of hard links to the file.
+    link-count: link-count,
+    /// For regular files, the file size in bytes. For symbolic links, the
+    /// length in bytes of the pathname contained in the symbolic link.
+    size: filesize,
+    /// Last data access timestamp.
+    ///
+    /// If the `option` is none, the platform doesn't maintain an access
+    /// timestamp for this file.
+    data-access-timestamp: option<datetime>,
+    /// Last data modification timestamp.
+    ///
+    /// If the `option` is none, the platform doesn't maintain a
+    /// modification timestamp for this file.
+    data-modification-timestamp: option<datetime>,
+    /// Last file status-change timestamp.
+    ///
+    /// If the `option` is none, the platform doesn't maintain a
+    /// status-change timestamp for this file.
+    status-change-timestamp: option<datetime>,
+  }
+
+  /// When setting a timestamp, this gives the value to set it to.
+  @since(version = 0.2.0)
+  variant new-timestamp {
+    /// Leave the timestamp set to its previous value.
+    no-change,
+    /// Set the timestamp to the current time of the system clock associated
+    /// with the filesystem.
+    now,
+    /// Set the timestamp to the given value.
+    timestamp(datetime),
+  }
+
+  /// A directory entry.
+  record directory-entry {
+    /// The type of the file referred to by this directory entry.
+    %type: descriptor-type,
+    /// The name of the object.
+    name: string,
+  }
+
+  /// Error codes returned by functions, similar to `errno` in POSIX.
+  /// Not all of these error codes are returned by the functions provided by this
+  /// API; some are used in higher-level library layers, and others are provided
+  /// merely for alignment with POSIX.
+  enum error-code {
+    /// Permission denied, similar to `EACCES` in POSIX.
+    access,
+    /// Resource unavailable, or operation would block, similar to `EAGAIN` and `EWOULDBLOCK` in POSIX.
+    would-block,
+    /// Connection already in progress, similar to `EALREADY` in POSIX.
+    already,
+    /// Bad descriptor, similar to `EBADF` in POSIX.
+    bad-descriptor,
+    /// Device or resource busy, similar to `EBUSY` in POSIX.
+    busy,
+    /// Resource deadlock would occur, similar to `EDEADLK` in POSIX.
+    deadlock,
+    /// Storage quota exceeded, similar to `EDQUOT` in POSIX.
+    quota,
+    /// File exists, similar to `EEXIST` in POSIX.
+    exist,
+    /// File too large, similar to `EFBIG` in POSIX.
+    file-too-large,
+    /// Illegal byte sequence, similar to `EILSEQ` in POSIX.
+    illegal-byte-sequence,
+    /// Operation in progress, similar to `EINPROGRESS` in POSIX.
+    in-progress,
+    /// Interrupted function, similar to `EINTR` in POSIX.
+    interrupted,
+    /// Invalid argument, similar to `EINVAL` in POSIX.
+    invalid,
+    /// I/O error, similar to `EIO` in POSIX.
+    io,
+    /// Is a directory, similar to `EISDIR` in POSIX.
+    is-directory,
+    /// Too many levels of symbolic links, similar to `ELOOP` in POSIX.
+    loop,
+    /// Too many links, similar to `EMLINK` in POSIX.
+    too-many-links,
+    /// Message too large, similar to `EMSGSIZE` in POSIX.
+    message-size,
+    /// Filename too long, similar to `ENAMETOOLONG` in POSIX.
+    name-too-long,
+    /// No such device, similar to `ENODEV` in POSIX.
+    no-device,
+    /// No such file or directory, similar to `ENOENT` in POSIX.
+    no-entry,
+    /// No locks available, similar to `ENOLCK` in POSIX.
+    no-lock,
+    /// Not enough space, similar to `ENOMEM` in POSIX.
+    insufficient-memory,
+    /// No space left on device, similar to `ENOSPC` in POSIX.
+    insufficient-space,
+    /// Not a directory or a symbolic link to a directory, similar to `ENOTDIR` in POSIX.
+    not-directory,
+    /// Directory not empty, similar to `ENOTEMPTY` in POSIX.
+    not-empty,
+    /// State not recoverable, similar to `ENOTRECOVERABLE` in POSIX.
+    not-recoverable,
+    /// Not supported, similar to `ENOTSUP` and `ENOSYS` in POSIX.
+    unsupported,
+    /// Inappropriate I/O control operation, similar to `ENOTTY` in POSIX.
+    no-tty,
+    /// No such device or address, similar to `ENXIO` in POSIX.
+    no-such-device,
+    /// Value too large to be stored in data type, similar to `EOVERFLOW` in POSIX.
+    overflow,
+    /// Operation not permitted, similar to `EPERM` in POSIX.
+    not-permitted,
+    /// Broken pipe, similar to `EPIPE` in POSIX.
+    pipe,
+    /// Read-only file system, similar to `EROFS` in POSIX.
+    read-only,
+    /// Invalid seek, similar to `ESPIPE` in POSIX.
+    invalid-seek,
+    /// Text file busy, similar to `ETXTBSY` in POSIX.
+    text-file-busy,
+    /// Cross-device link, similar to `EXDEV` in POSIX.
+    cross-device,
+  }
+
+  /// File or memory access pattern advisory information.
+  @since(version = 0.2.0)
+  enum advice {
+    /// The application has no advice to give on its behavior with respect
+    /// to the specified data.
+    normal,
+    /// The application expects to access the specified data sequentially
+    /// from lower offsets to higher offsets.
+    sequential,
+    /// The application expects to access the specified data in a random
+    /// order.
+    random,
+    /// The application expects to access the specified data in the near
+    /// future.
+    will-need,
+    /// The application expects that it will not access the specified data
+    /// in the near future.
+    dont-need,
+    /// The application expects to access the specified data once and then
+    /// not reuse it thereafter.
+    no-reuse,
+  }
+
+  /// A 128-bit hash value, split into parts because wasm doesn't have a
+  /// 128-bit integer type.
+  @since(version = 0.2.0)
+  record metadata-hash-value {
+    /// 64 bits of a 128-bit hash value.
+    lower: u64,
+    /// Another 64 bits of a 128-bit hash value.
+    upper: u64,
+  }
+
+  /// A descriptor is a reference to a filesystem object, which may be a file,
+  /// directory, named pipe, special file, or other object on which filesystem
+  /// calls may be made.
+  @since(version = 0.2.0)
+  resource descriptor {
+    /// Return a stream for reading from a file, if available.
+    ///
+    /// May fail with an error-code describing why the file cannot be read.
+    ///
+    /// Multiple read, write, and append streams may be active on the same open
+    /// file and they do not interfere with each other.
+    ///
+    /// Note: This allows using `read-stream`, which is similar to `read` in POSIX.
+    @since(version = 0.2.0)
+    read-via-stream: func(offset: filesize) -> result<input-stream, error-code>;
+    /// Return a stream for writing to a file, if available.
+    ///
+    /// May fail with an error-code describing why the file cannot be written.
+    ///
+    /// Note: This allows using `write-stream`, which is similar to `write` in
+    /// POSIX.
+    @since(version = 0.2.0)
+    write-via-stream: func(offset: filesize) -> result<output-stream, error-code>;
+    /// Return a stream for appending to a file, if available.
+    ///
+    /// May fail with an error-code describing why the file cannot be appended.
+    ///
+    /// Note: This allows using `write-stream`, which is similar to `write` with
+    /// `O_APPEND` in POSIX.
+    @since(version = 0.2.0)
+    append-via-stream: func() -> result<output-stream, error-code>;
+    /// Provide file advisory information on a descriptor.
+    ///
+    /// This is similar to `posix_fadvise` in POSIX.
+    @since(version = 0.2.0)
+    advise: func(offset: filesize, length: filesize, advice: advice) -> result<_, error-code>;
+    /// Synchronize the data of a file to disk.
+    ///
+    /// This function succeeds with no effect if the file descriptor is not
+    /// opened for writing.
+    ///
+    /// Note: This is similar to `fdatasync` in POSIX.
+    @since(version = 0.2.0)
+    sync-data: func() -> result<_, error-code>;
+    /// Get flags associated with a descriptor.
+    ///
+    /// Note: This returns similar flags to `fcntl(fd, F_GETFL)` in POSIX.
+    ///
+    /// Note: This returns the value that was the `fs_flags` value returned
+    /// from `fdstat_get` in earlier versions of WASI.
+    @since(version = 0.2.0)
+    get-flags: func() -> result<descriptor-flags, error-code>;
+    /// Get the dynamic type of a descriptor.
+    ///
+    /// Note: This returns the same value as the `type` field of the `fd-stat`
+    /// returned by `stat`, `stat-at` and similar.
+    ///
+    /// Note: This returns similar flags to the `st_mode & S_IFMT` value provided
+    /// by `fstat` in POSIX.
+    ///
+    /// Note: This returns the value that was the `fs_filetype` value returned
+    /// from `fdstat_get` in earlier versions of WASI.
+    @since(version = 0.2.0)
+    get-type: func() -> result<descriptor-type, error-code>;
+    /// Adjust the size of an open file. If this increases the file's size, the
+    /// extra bytes are filled with zeros.
+    ///
+    /// Note: This was called `fd_filestat_set_size` in earlier versions of WASI.
+    @since(version = 0.2.0)
+    set-size: func(size: filesize) -> result<_, error-code>;
+    /// Adjust the timestamps of an open file or directory.
+    ///
+    /// Note: This is similar to `futimens` in POSIX.
+    ///
+    /// Note: This was called `fd_filestat_set_times` in earlier versions of WASI.
+    @since(version = 0.2.0)
+    set-times: func(data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp) -> result<_, error-code>;
+    /// Read from a descriptor, without using and updating the descriptor's offset.
+    ///
+    /// This function returns a list of bytes containing the data that was
+    /// read, along with a bool which, when true, indicates that the end of the
+    /// file was reached. The returned list will contain up to `length` bytes; it
+    /// may return fewer than requested, if the end of the file is reached or
+    /// if the I/O operation is interrupted.
+    ///
+    /// In the future, this may change to return a `stream<u8, error-code>`.
+    ///
+    /// Note: This is similar to `pread` in POSIX.
+    @since(version = 0.2.0)
+    read: func(length: filesize, offset: filesize) -> result<tuple<list<u8>, bool>, error-code>;
+    /// Write to a descriptor, without using and updating the descriptor's offset.
+    ///
+    /// It is valid to write past the end of a file; the file is extended to the
+    /// extent of the write, with bytes between the previous end and the start of
+    /// the write set to zero.
+    ///
+    /// In the future, this may change to take a `stream<u8, error-code>`.
+    ///
+    /// Note: This is similar to `pwrite` in POSIX.
+    @since(version = 0.2.0)
+    write: func(buffer: list<u8>, offset: filesize) -> result<filesize, error-code>;
+    /// Read directory entries from a directory.
+    ///
+    /// On filesystems where directories contain entries referring to themselves
+    /// and their parents, often named `.` and `..` respectively, these entries
+    /// are omitted.
+    ///
+    /// This always returns a new stream which starts at the beginning of the
+    /// directory. Multiple streams may be active on the same directory, and they
+    /// do not interfere with each other.
+    @since(version = 0.2.0)
+    read-directory: func() -> result<directory-entry-stream, error-code>;
+    /// Synchronize the data and metadata of a file to disk.
+    ///
+    /// This function succeeds with no effect if the file descriptor is not
+    /// opened for writing.
+    ///
+    /// Note: This is similar to `fsync` in POSIX.
+    @since(version = 0.2.0)
+    sync: func() -> result<_, error-code>;
+    /// Create a directory.
+    ///
+    /// Note: This is similar to `mkdirat` in POSIX.
+    @since(version = 0.2.0)
+    create-directory-at: func(path: string) -> result<_, error-code>;
+    /// Return the attributes of an open file or directory.
+    ///
+    /// Note: This is similar to `fstat` in POSIX, except that it does not return
+    /// device and inode information. For testing whether two descriptors refer to
+    /// the same underlying filesystem object, use `is-same-object`. To obtain
+    /// additional data that can be used do determine whether a file has been
+    /// modified, use `metadata-hash`.
+    ///
+    /// Note: This was called `fd_filestat_get` in earlier versions of WASI.
+    @since(version = 0.2.0)
+    stat: func() -> result<descriptor-stat, error-code>;
+    /// Return the attributes of a file or directory.
+    ///
+    /// Note: This is similar to `fstatat` in POSIX, except that it does not
+    /// return device and inode information. See the `stat` description for a
+    /// discussion of alternatives.
+    ///
+    /// Note: This was called `path_filestat_get` in earlier versions of WASI.
+    @since(version = 0.2.0)
+    stat-at: func(path-flags: path-flags, path: string) -> result<descriptor-stat, error-code>;
+    /// Adjust the timestamps of a file or directory.
+    ///
+    /// Note: This is similar to `utimensat` in POSIX.
+    ///
+    /// Note: This was called `path_filestat_set_times` in earlier versions of
+    /// WASI.
+    @since(version = 0.2.0)
+    set-times-at: func(path-flags: path-flags, path: string, data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp) -> result<_, error-code>;
+    /// Create a hard link.
+    ///
+    /// Fails with `error-code::no-entry` if the old path does not exist,
+    /// with `error-code::exist` if the new path already exists, and
+    /// `error-code::not-permitted` if the old path is not a file.
+    ///
+    /// Note: This is similar to `linkat` in POSIX.
+    @since(version = 0.2.0)
+    link-at: func(old-path-flags: path-flags, old-path: string, new-descriptor: borrow<descriptor>, new-path: string) -> result<_, error-code>;
+    /// Open a file or directory.
+    ///
+    /// If `flags` contains `descriptor-flags::mutate-directory`, and the base
+    /// descriptor doesn't have `descriptor-flags::mutate-directory` set,
+    /// `open-at` fails with `error-code::read-only`.
+    ///
+    /// If `flags` contains `write` or `mutate-directory`, or `open-flags`
+    /// contains `truncate` or `create`, and the base descriptor doesn't have
+    /// `descriptor-flags::mutate-directory` set, `open-at` fails with
+    /// `error-code::read-only`.
+    ///
+    /// Note: This is similar to `openat` in POSIX.
+    @since(version = 0.2.0)
+    open-at: func(path-flags: path-flags, path: string, open-flags: open-flags, %flags: descriptor-flags) -> result<descriptor, error-code>;
+    /// Read the contents of a symbolic link.
+    ///
+    /// If the contents contain an absolute or rooted path in the underlying
+    /// filesystem, this function fails with `error-code::not-permitted`.
+    ///
+    /// Note: This is similar to `readlinkat` in POSIX.
+    @since(version = 0.2.0)
+    readlink-at: func(path: string) -> result<string, error-code>;
+    /// Remove a directory.
+    ///
+    /// Return `error-code::not-empty` if the directory is not empty.
+    ///
+    /// Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
+    @since(version = 0.2.0)
+    remove-directory-at: func(path: string) -> result<_, error-code>;
+    /// Rename a filesystem object.
+    ///
+    /// Note: This is similar to `renameat` in POSIX.
+    @since(version = 0.2.0)
+    rename-at: func(old-path: string, new-descriptor: borrow<descriptor>, new-path: string) -> result<_, error-code>;
+    /// Create a symbolic link (also known as a "symlink").
+    ///
+    /// If `old-path` starts with `/`, the function fails with
+    /// `error-code::not-permitted`.
+    ///
+    /// Note: This is similar to `symlinkat` in POSIX.
+    @since(version = 0.2.0)
+    symlink-at: func(old-path: string, new-path: string) -> result<_, error-code>;
+    /// Unlink a filesystem object that is not a directory.
+    ///
+    /// Return `error-code::is-directory` if the path refers to a directory.
+    /// Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
+    @since(version = 0.2.0)
+    unlink-file-at: func(path: string) -> result<_, error-code>;
+    /// Test whether two descriptors refer to the same filesystem object.
+    ///
+    /// In POSIX, this corresponds to testing whether the two descriptors have the
+    /// same device (`st_dev`) and inode (`st_ino` or `d_ino`) numbers.
+    /// wasi-filesystem does not expose device and inode numbers, so this function
+    /// may be used instead.
+    @since(version = 0.2.0)
+    is-same-object: func(other: borrow<descriptor>) -> bool;
+    /// Return a hash of the metadata associated with a filesystem object referred
+    /// to by a descriptor.
+    ///
+    /// This returns a hash of the last-modification timestamp and file size, and
+    /// may also include the inode number, device number, birth timestamp, and
+    /// other metadata fields that may change when the file is modified or
+    /// replaced. It may also include a secret value chosen by the
+    /// implementation and not otherwise exposed.
+    ///
+    /// Implementations are encouraged to provide the following properties:
+    ///
+    ///  - If the file is not modified or replaced, the computed hash value should
+    ///    usually not change.
+    ///  - If the object is modified or replaced, the computed hash value should
+    ///    usually change.
+    ///  - The inputs to the hash should not be easily computable from the
+    ///    computed hash.
+    ///
+    /// However, none of these is required.
+    @since(version = 0.2.0)
+    metadata-hash: func() -> result<metadata-hash-value, error-code>;
+    /// Return a hash of the metadata associated with a filesystem object referred
+    /// to by a directory descriptor and a relative path.
+    ///
+    /// This performs the same hash computation as `metadata-hash`.
+    @since(version = 0.2.0)
+    metadata-hash-at: func(path-flags: path-flags, path: string) -> result<metadata-hash-value, error-code>;
+  }
+
+  /// A stream of directory entries.
+  @since(version = 0.2.0)
+  resource directory-entry-stream {
+    /// Read a single directory entry from a `directory-entry-stream`.
+    @since(version = 0.2.0)
+    read-directory-entry: func() -> result<option<directory-entry>, error-code>;
+  }
+
+  /// Attempts to extract a filesystem-related `error-code` from the stream
+  /// `error` provided.
+  ///
+  /// Stream operations which return `stream-error::last-operation-failed`
+  /// have a payload with more information about the operation that failed.
+  /// This payload can be passed through to this function to see if there's
+  /// filesystem-related information about the error to return.
+  ///
+  /// Note that this function is fallible because not all stream-related
+  /// errors are filesystem-related errors.
+  @since(version = 0.2.0)
+  filesystem-error-code: func(err: borrow<error>) -> option<error-code>;
+}
+
+@since(version = 0.2.0)
+interface preopens {
+  @since(version = 0.2.0)
+  use types.{descriptor};
+
+  /// Return the set of preopened directories, and their paths.
+  @since(version = 0.2.0)
+  get-directories: func() -> list<tuple<descriptor, string>>;
+}
+
+@since(version = 0.2.0)
+world imports {
+  @since(version = 0.2.0)
+  import wasi:io/error@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:io/poll@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:io/streams@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:clocks/wall-clock@0.2.6;
+  @since(version = 0.2.0)
+  import types;
+  @since(version = 0.2.0)
+  import preopens;
+}
diff --git a/sdks/go/golem/wit/deps/filesystem/filesystem.wit b/sdks/go/golem/wit/deps/filesystem/filesystem.wit
new file mode 100644
index 0000000000..e4a778f3d2
--- /dev/null
+++ b/sdks/go/golem/wit/deps/filesystem/filesystem.wit
@@ -0,0 +1,575 @@
+package wasi:filesystem@0.3.0;
+
+/// WASI filesystem is a filesystem API primarily intended to let users run WASI
+/// programs that access their files on their existing filesystems, without
+/// significant overhead.
+///
+/// Paths are passed as interface-type `string`s, meaning they must consist of
+/// a sequence of Unicode Scalar Values (USVs). Some filesystems may contain
+/// paths which are not accessible by this API.
+///
+/// The directory separator in WASI is always the forward-slash (`/`).
+///
+/// All paths in WASI are relative paths, and are interpreted relative to a
+/// `descriptor` referring to a base directory. If a `path` argument to any WASI
+/// function starts with `/`, or if any step of resolving a `path`, including
+/// `..` and symbolic link steps, reaches a directory outside of the base
+/// directory, or reaches a symlink to an absolute or rooted path in the
+/// underlying filesystem, the function fails with `error-code::not-permitted`.
+///
+/// For more information about WASI path resolution and sandboxing, see
+/// [WASI filesystem path resolution].
+///
+/// Though this package presents a portable interface modelled on POSIX, it
+/// prioritizes compatibility over portability: allowing users to access their
+/// files on their machine is more important than exposing a single semantics
+/// across all platforms.  Notably, depending on the underlying operating system
+/// and file system:
+///   * Paths may be case-folded or not.
+///   * Deleting (unlinking) a file may fail if there are other file descriptors
+///     open.
+///   * Durability and atomicity of changes to underlying files when there are
+///     concurrent writers.
+///
+/// Users that need well-defined, portable semantics should use a key-value
+/// store or a database instead.
+///
+/// [WASI filesystem path resolution]: https://github.com/WebAssembly/wasi-filesystem/blob/main/path-resolution.md
+@since(version = 0.3.0)
+interface types {
+  @since(version = 0.3.0)
+  use wasi:clocks/system-clock@0.3.0.{instant};
+
+  /// File size or length of a region within a file.
+  @since(version = 0.3.0)
+  type filesize = u64;
+
+  /// The type of a filesystem object referenced by a descriptor.
+  ///
+  /// Note: This was called `filetype` in earlier versions of WASI.
+  @since(version = 0.3.0)
+  variant descriptor-type {
+    /// The descriptor refers to a block device inode.
+    block-device,
+    /// The descriptor refers to a character device inode.
+    character-device,
+    /// The descriptor refers to a directory inode.
+    directory,
+    /// The descriptor refers to a named pipe.
+    fifo,
+    /// The file refers to a symbolic link inode.
+    symbolic-link,
+    /// The descriptor refers to a regular file inode.
+    regular-file,
+    /// The descriptor refers to a socket.
+    socket,
+    /// The type of the descriptor or file is different from any of the
+    /// other types specified.
+    other(option<string>),
+  }
+
+  /// Descriptor flags.
+  ///
+  /// Note: This was called `fdflags` in earlier versions of WASI.
+  @since(version = 0.3.0)
+  flags descriptor-flags {
+    /// Read mode: Data can be read.
+    read,
+    /// Write mode: Data can be written to.
+    write,
+    /// Request that writes be performed according to synchronized I/O file
+    /// integrity completion. The data stored in the file and the file's
+    /// metadata are synchronized. This is similar to `O_SYNC` in POSIX.
+    ///
+    /// The precise semantics of this operation have not yet been defined for
+    /// WASI. At this time, it should be interpreted as a request, and not a
+    /// requirement.
+    file-integrity-sync,
+    /// Request that writes be performed according to synchronized I/O data
+    /// integrity completion. Only the data stored in the file is
+    /// synchronized. This is similar to `O_DSYNC` in POSIX.
+    ///
+    /// The precise semantics of this operation have not yet been defined for
+    /// WASI. At this time, it should be interpreted as a request, and not a
+    /// requirement.
+    data-integrity-sync,
+    /// Requests that reads be performed at the same level of integrity
+    /// requested for writes. This is similar to `O_RSYNC` in POSIX.
+    ///
+    /// The precise semantics of this operation have not yet been defined for
+    /// WASI. At this time, it should be interpreted as a request, and not a
+    /// requirement.
+    requested-write-sync,
+    /// Mutating directories mode: Directory contents may be mutated.
+    ///
+    /// When this flag is unset on a descriptor, operations using the
+    /// descriptor which would create, rename, delete, modify the data or
+    /// metadata of filesystem objects, or obtain another handle which
+    /// would permit any of those, shall fail with `error-code::read-only` if
+    /// they would otherwise succeed.
+    ///
+    /// This may only be set on directories.
+    mutate-directory,
+  }
+
+  /// Flags determining the method of how paths are resolved.
+  @since(version = 0.3.0)
+  flags path-flags {
+    /// As long as the resolved path corresponds to a symbolic link, it is
+    /// expanded.
+    symlink-follow,
+  }
+
+  /// Open flags used by `open-at`.
+  @since(version = 0.3.0)
+  flags open-flags {
+    /// Create file if it does not exist, similar to `O_CREAT` in POSIX.
+    create,
+    /// Fail if not a directory, similar to `O_DIRECTORY` in POSIX.
+    directory,
+    /// Fail if file already exists, similar to `O_EXCL` in POSIX.
+    exclusive,
+    /// Truncate file to size 0, similar to `O_TRUNC` in POSIX.
+    truncate,
+  }
+
+  /// Number of hard links to an inode.
+  @since(version = 0.3.0)
+  type link-count = u64;
+
+  /// File attributes.
+  ///
+  /// Note: This was called `filestat` in earlier versions of WASI.
+  @since(version = 0.3.0)
+  record descriptor-stat {
+    /// File type.
+    %type: descriptor-type,
+    /// Number of hard links to the file.
+    link-count: link-count,
+    /// For regular files, the file size in bytes. For symbolic links, the
+    /// length in bytes of the pathname contained in the symbolic link.
+    size: filesize,
+    /// Last data access timestamp.
+    ///
+    /// If the `option` is none, the platform doesn't maintain an access
+    /// timestamp for this file.
+    data-access-timestamp: option<instant>,
+    /// Last data modification timestamp.
+    ///
+    /// If the `option` is none, the platform doesn't maintain a
+    /// modification timestamp for this file.
+    data-modification-timestamp: option<instant>,
+    /// Last file status-change timestamp.
+    ///
+    /// If the `option` is none, the platform doesn't maintain a
+    /// status-change timestamp for this file.
+    status-change-timestamp: option<instant>,
+  }
+
+  /// When setting a timestamp, this gives the value to set it to.
+  @since(version = 0.3.0)
+  variant new-timestamp {
+    /// Leave the timestamp set to its previous value.
+    no-change,
+    /// Set the timestamp to the current time of the system clock associated
+    /// with the filesystem.
+    now,
+    /// Set the timestamp to the given value.
+    timestamp(instant),
+  }
+
+  /// A directory entry.
+  @since(version = 0.3.0)
+  record directory-entry {
+    /// The type of the file referred to by this directory entry.
+    %type: descriptor-type,
+    /// The name of the object.
+    name: string,
+  }
+
+  /// Error codes returned by functions, similar to `errno` in POSIX.
+  /// Not all of these error codes are returned by the functions provided by this
+  /// API; some are used in higher-level library layers, and others are provided
+  /// merely for alignment with POSIX.
+  @since(version = 0.3.0)
+  variant error-code {
+    /// Permission denied, similar to `EACCES` in POSIX.
+    access,
+    /// Connection already in progress, similar to `EALREADY` in POSIX.
+    already,
+    /// Bad descriptor, similar to `EBADF` in POSIX.
+    bad-descriptor,
+    /// Device or resource busy, similar to `EBUSY` in POSIX.
+    busy,
+    /// Resource deadlock would occur, similar to `EDEADLK` in POSIX.
+    deadlock,
+    /// Storage quota exceeded, similar to `EDQUOT` in POSIX.
+    quota,
+    /// File exists, similar to `EEXIST` in POSIX.
+    exist,
+    /// File too large, similar to `EFBIG` in POSIX.
+    file-too-large,
+    /// Illegal byte sequence, similar to `EILSEQ` in POSIX.
+    illegal-byte-sequence,
+    /// Operation in progress, similar to `EINPROGRESS` in POSIX.
+    in-progress,
+    /// Interrupted function, similar to `EINTR` in POSIX.
+    interrupted,
+    /// Invalid argument, similar to `EINVAL` in POSIX.
+    invalid,
+    /// I/O error, similar to `EIO` in POSIX.
+    io,
+    /// Is a directory, similar to `EISDIR` in POSIX.
+    is-directory,
+    /// Too many levels of symbolic links, similar to `ELOOP` in POSIX.
+    loop,
+    /// Too many links, similar to `EMLINK` in POSIX.
+    too-many-links,
+    /// Message too large, similar to `EMSGSIZE` in POSIX.
+    message-size,
+    /// Filename too long, similar to `ENAMETOOLONG` in POSIX.
+    name-too-long,
+    /// No such device, similar to `ENODEV` in POSIX.
+    no-device,
+    /// No such file or directory, similar to `ENOENT` in POSIX.
+    no-entry,
+    /// No locks available, similar to `ENOLCK` in POSIX.
+    no-lock,
+    /// Not enough space, similar to `ENOMEM` in POSIX.
+    insufficient-memory,
+    /// No space left on device, similar to `ENOSPC` in POSIX.
+    insufficient-space,
+    /// Not a directory or a symbolic link to a directory, similar to `ENOTDIR` in POSIX.
+    not-directory,
+    /// Directory not empty, similar to `ENOTEMPTY` in POSIX.
+    not-empty,
+    /// State not recoverable, similar to `ENOTRECOVERABLE` in POSIX.
+    not-recoverable,
+    /// Not supported, similar to `ENOTSUP` and `ENOSYS` in POSIX.
+    unsupported,
+    /// Inappropriate I/O control operation, similar to `ENOTTY` in POSIX.
+    no-tty,
+    /// No such device or address, similar to `ENXIO` in POSIX.
+    no-such-device,
+    /// Value too large to be stored in data type, similar to `EOVERFLOW` in POSIX.
+    overflow,
+    /// Operation not permitted, similar to `EPERM` in POSIX.
+    not-permitted,
+    /// Broken pipe, similar to `EPIPE` in POSIX.
+    pipe,
+    /// Read-only file system, similar to `EROFS` in POSIX.
+    read-only,
+    /// Invalid seek, similar to `ESPIPE` in POSIX.
+    invalid-seek,
+    /// Text file busy, similar to `ETXTBSY` in POSIX.
+    text-file-busy,
+    /// Cross-device link, similar to `EXDEV` in POSIX.
+    cross-device,
+    /// A catch-all for errors not captured by the existing variants.
+    /// Implementations can use this to extend the error type without
+    /// breaking existing code.
+    other(option<string>),
+  }
+
+  /// File or memory access pattern advisory information.
+  @since(version = 0.3.0)
+  enum advice {
+    /// The application has no advice to give on its behavior with respect
+    /// to the specified data.
+    normal,
+    /// The application expects to access the specified data sequentially
+    /// from lower offsets to higher offsets.
+    sequential,
+    /// The application expects to access the specified data in a random
+    /// order.
+    random,
+    /// The application expects to access the specified data in the near
+    /// future.
+    will-need,
+    /// The application expects that it will not access the specified data
+    /// in the near future.
+    dont-need,
+    /// The application expects to access the specified data once and then
+    /// not reuse it thereafter.
+    no-reuse,
+  }
+
+  /// A 128-bit hash value, split into parts because wasm doesn't have a
+  /// 128-bit integer type.
+  @since(version = 0.3.0)
+  record metadata-hash-value {
+    /// 64 bits of a 128-bit hash value.
+    lower: u64,
+    /// Another 64 bits of a 128-bit hash value.
+    upper: u64,
+  }
+
+  /// A descriptor is a reference to a filesystem object, which may be a file,
+  /// directory, named pipe, special file, or other object on which filesystem
+  /// calls may be made.
+  @since(version = 0.3.0)
+  resource descriptor {
+    /// Return a stream for reading from a file.
+    ///
+    /// Multiple read, write, and append streams may be active on the same open
+    /// file and they do not interfere with each other.
+    ///
+    /// This function returns a `stream` which provides the data received from the
+    /// file, and a `future` providing additional error information in case an
+    /// error is encountered.
+    ///
+    /// If no error is encountered, `stream.read` on the `stream` will return
+    /// `read-status::closed` with no `error-context` and the future resolves to
+    /// the value `ok`. If an error is encountered, `stream.read` on the
+    /// `stream` returns `read-status::closed` with an `error-context` and the future
+    /// resolves to `err` with an `error-code`.
+    ///
+    /// Note: This is similar to `pread` in POSIX.
+    @since(version = 0.3.0)
+    read-via-stream: func(offset: filesize) -> tuple<stream<u8>, future<result<_, error-code>>>;
+    /// Return a stream for writing to a file, if available.
+    ///
+    /// May fail with an error-code describing why the file cannot be written.
+    ///
+    /// It is valid to write past the end of a file; the file is extended to the
+    /// extent of the write, with bytes between the previous end and the start of
+    /// the write set to zero.
+    ///
+    /// This function returns once either full contents of the stream are
+    /// written or an error is encountered.
+    ///
+    /// Note: This is similar to `pwrite` in POSIX.
+    @since(version = 0.3.0)
+    write-via-stream: func(data: stream<u8>, offset: filesize) -> future<result<_, error-code>>;
+    /// Return a stream for appending to a file, if available.
+    ///
+    /// May fail with an error-code describing why the file cannot be appended.
+    ///
+    /// This function returns once either full contents of the stream are
+    /// written or an error is encountered.
+    ///
+    /// Note: This is similar to `write` with `O_APPEND` in POSIX.
+    @since(version = 0.3.0)
+    append-via-stream: func(data: stream<u8>) -> future<result<_, error-code>>;
+    /// Provide file advisory information on a descriptor.
+    ///
+    /// This is similar to `posix_fadvise` in POSIX.
+    @since(version = 0.3.0)
+    advise: async func(offset: filesize, length: filesize, advice: advice) -> result<_, error-code>;
+    /// Synchronize the data of a file to disk.
+    ///
+    /// This function succeeds with no effect if the file descriptor is not
+    /// opened for writing.
+    ///
+    /// Note: This is similar to `fdatasync` in POSIX.
+    @since(version = 0.3.0)
+    sync-data: async func() -> result<_, error-code>;
+    /// Get flags associated with a descriptor.
+    ///
+    /// Note: This returns similar flags to `fcntl(fd, F_GETFL)` in POSIX.
+    ///
+    /// Note: This returns the value that was the `fs_flags` value returned
+    /// from `fdstat_get` in earlier versions of WASI.
+    @since(version = 0.3.0)
+    get-flags: async func() -> result<descriptor-flags, error-code>;
+    /// Get the dynamic type of a descriptor.
+    ///
+    /// Note: This returns the same value as the `type` field of the `fd-stat`
+    /// returned by `stat`, `stat-at` and similar.
+    ///
+    /// Note: This returns similar flags to the `st_mode & S_IFMT` value provided
+    /// by `fstat` in POSIX.
+    ///
+    /// Note: This returns the value that was the `fs_filetype` value returned
+    /// from `fdstat_get` in earlier versions of WASI.
+    @since(version = 0.3.0)
+    get-type: async func() -> result<descriptor-type, error-code>;
+    /// Adjust the size of an open file. If this increases the file's size, the
+    /// extra bytes are filled with zeros.
+    ///
+    /// Note: This was called `fd_filestat_set_size` in earlier versions of WASI.
+    @since(version = 0.3.0)
+    set-size: async func(size: filesize) -> result<_, error-code>;
+    /// Adjust the timestamps of an open file or directory.
+    ///
+    /// Note: This is similar to `futimens` in POSIX.
+    ///
+    /// Note: This was called `fd_filestat_set_times` in earlier versions of WASI.
+    @since(version = 0.3.0)
+    set-times: async func(data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp) -> result<_, error-code>;
+    /// Read directory entries from a directory.
+    ///
+    /// On filesystems where directories contain entries referring to themselves
+    /// and their parents, often named `.` and `..` respectively, these entries
+    /// are omitted.
+    ///
+    /// This always returns a new stream which starts at the beginning of the
+    /// directory. Multiple streams may be active on the same directory, and they
+    /// do not interfere with each other.
+    ///
+    /// This function returns a future, which will resolve to an error code if
+    /// reading full contents of the directory fails.
+    @since(version = 0.3.0)
+    read-directory: func() -> tuple<stream<directory-entry>, future<result<_, error-code>>>;
+    /// Synchronize the data and metadata of a file to disk.
+    ///
+    /// This function succeeds with no effect if the file descriptor is not
+    /// opened for writing.
+    ///
+    /// Note: This is similar to `fsync` in POSIX.
+    @since(version = 0.3.0)
+    sync: async func() -> result<_, error-code>;
+    /// Create a directory.
+    ///
+    /// Note: This is similar to `mkdirat` in POSIX.
+    @since(version = 0.3.0)
+    create-directory-at: async func(path: string) -> result<_, error-code>;
+    /// Return the attributes of an open file or directory.
+    ///
+    /// Note: This is similar to `fstat` in POSIX, except that it does not return
+    /// device and inode information. For testing whether two descriptors refer to
+    /// the same underlying filesystem object, use `is-same-object`. To obtain
+    /// additional data that can be used do determine whether a file has been
+    /// modified, use `metadata-hash`.
+    ///
+    /// Note: This was called `fd_filestat_get` in earlier versions of WASI.
+    @since(version = 0.3.0)
+    stat: async func() -> result<descriptor-stat, error-code>;
+    /// Return the attributes of a file or directory.
+    ///
+    /// Note: This is similar to `fstatat` in POSIX, except that it does not
+    /// return device and inode information. See the `stat` description for a
+    /// discussion of alternatives.
+    ///
+    /// Note: This was called `path_filestat_get` in earlier versions of WASI.
+    @since(version = 0.3.0)
+    stat-at: async func(path-flags: path-flags, path: string) -> result<descriptor-stat, error-code>;
+    /// Adjust the timestamps of a file or directory.
+    ///
+    /// Note: This is similar to `utimensat` in POSIX.
+    ///
+    /// Note: This was called `path_filestat_set_times` in earlier versions of
+    /// WASI.
+    @since(version = 0.3.0)
+    set-times-at: async func(path-flags: path-flags, path: string, data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp) -> result<_, error-code>;
+    /// Create a hard link.
+    ///
+    /// Fails with `error-code::no-entry` if the old path does not exist,
+    /// with `error-code::exist` if the new path already exists, and
+    /// `error-code::not-permitted` if the old path is not a file.
+    ///
+    /// Note: This is similar to `linkat` in POSIX.
+    @since(version = 0.3.0)
+    link-at: async func(old-path-flags: path-flags, old-path: string, new-descriptor: borrow<descriptor>, new-path: string) -> result<_, error-code>;
+    /// Open a file or directory.
+    ///
+    /// If `flags` contains `descriptor-flags::mutate-directory`, and the base
+    /// descriptor doesn't have `descriptor-flags::mutate-directory` set,
+    /// `open-at` fails with `error-code::read-only`.
+    ///
+    /// If `flags` contains `write` or `mutate-directory`, or `open-flags`
+    /// contains `truncate` or `create`, and the base descriptor doesn't have
+    /// `descriptor-flags::mutate-directory` set, `open-at` fails with
+    /// `error-code::read-only`.
+    ///
+    /// Note: This is similar to `openat` in POSIX.
+    @since(version = 0.3.0)
+    open-at: async func(path-flags: path-flags, path: string, open-flags: open-flags, %flags: descriptor-flags) -> result<descriptor, error-code>;
+    /// Read the contents of a symbolic link.
+    ///
+    /// If the contents contain an absolute or rooted path in the underlying
+    /// filesystem, this function fails with `error-code::not-permitted`.
+    ///
+    /// Note: This is similar to `readlinkat` in POSIX.
+    @since(version = 0.3.0)
+    readlink-at: async func(path: string) -> result<string, error-code>;
+    /// Remove a directory.
+    ///
+    /// Return `error-code::not-empty` if the directory is not empty.
+    ///
+    /// Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
+    @since(version = 0.3.0)
+    remove-directory-at: async func(path: string) -> result<_, error-code>;
+    /// Rename a filesystem object.
+    ///
+    /// Note: This is similar to `renameat` in POSIX.
+    @since(version = 0.3.0)
+    rename-at: async func(old-path: string, new-descriptor: borrow<descriptor>, new-path: string) -> result<_, error-code>;
+    /// Create a symbolic link (also known as a "symlink").
+    ///
+    /// If `old-path` starts with `/`, the function fails with
+    /// `error-code::not-permitted`.
+    ///
+    /// Note: This is similar to `symlinkat` in POSIX.
+    @since(version = 0.3.0)
+    symlink-at: async func(old-path: string, new-path: string) -> result<_, error-code>;
+    /// Unlink a filesystem object that is not a directory.
+    ///
+    /// This is similar to `unlinkat(fd, path, 0)` in POSIX.
+    ///
+    /// Error returns are as specified by POSIX.
+    ///
+    /// If the filesystem object is a directory, `error-code::access` or
+    /// `error-code::is-directory` may be returned instead of the
+    /// POSIX-specified `error-code::not-permitted`.
+    @since(version = 0.3.0)
+    unlink-file-at: async func(path: string) -> result<_, error-code>;
+    /// Test whether two descriptors refer to the same filesystem object.
+    ///
+    /// In POSIX, this corresponds to testing whether the two descriptors have the
+    /// same device (`st_dev`) and inode (`st_ino` or `d_ino`) numbers.
+    /// wasi-filesystem does not expose device and inode numbers, so this function
+    /// may be used instead.
+    @since(version = 0.3.0)
+    is-same-object: async func(other: borrow<descriptor>) -> bool;
+    /// Return a hash of the metadata associated with a filesystem object referred
+    /// to by a descriptor.
+    ///
+    /// This returns a hash of the last-modification timestamp and file size, and
+    /// may also include the inode number, device number, birth timestamp, and
+    /// other metadata fields that may change when the file is modified or
+    /// replaced. It may also include a secret value chosen by the
+    /// implementation and not otherwise exposed.
+    ///
+    /// Implementations are encouraged to provide the following properties:
+    ///
+    ///  - If the file is not modified or replaced, the computed hash value should
+    ///    usually not change.
+    ///  - If the object is modified or replaced, the computed hash value should
+    ///    usually change.
+    ///  - The inputs to the hash should not be easily computable from the
+    ///    computed hash.
+    ///
+    /// However, none of these is required.
+    @since(version = 0.3.0)
+    metadata-hash: async func() -> result<metadata-hash-value, error-code>;
+    /// Return a hash of the metadata associated with a filesystem object referred
+    /// to by a directory descriptor and a relative path.
+    ///
+    /// This performs the same hash computation as `metadata-hash`.
+    @since(version = 0.3.0)
+    metadata-hash-at: async func(path-flags: path-flags, path: string) -> result<metadata-hash-value, error-code>;
+  }
+}
+
+@since(version = 0.3.0)
+interface preopens {
+  @since(version = 0.3.0)
+  use types.{descriptor};
+
+  /// Return the set of preopened directories, and their paths.
+  @since(version = 0.3.0)
+  get-directories: func() -> list<tuple<descriptor, string>>;
+}
+
+@since(version = 0.3.0)
+world imports {
+  @since(version = 0.3.0)
+  import wasi:clocks/types@0.3.0;
+  @since(version = 0.3.0)
+  import wasi:clocks/system-clock@0.3.0;
+  @since(version = 0.3.0)
+  import types;
+  @since(version = 0.3.0)
+  import preopens;
+}
diff --git a/sdks/go/golem/wit/deps/golem-1.x/golem-context.wit b/sdks/go/golem/wit/deps/golem-1.x/golem-context.wit
new file mode 100644
index 0000000000..aa3252a487
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-1.x/golem-context.wit
@@ -0,0 +1,93 @@
+package golem:api@1.5.0;
+
+/// Invocation context support
+interface context {
+    use wasi:clocks/system-clock@0.3.0.{instant as datetime};
+
+    /// Starts a new `span` with the given name, as a child of the current invocation context
+    start-span: func(name: string) -> span;
+
+    /// Gets the current invocation context
+    ///
+    /// The function call captures the current context; if new spans are started, the returned `invocation-context` instance will not
+    /// reflect that.
+    current-context: func() -> invocation-context;
+
+    /// Allows or disallows forwarding of trace context headers in outgoing HTTP requests
+    ///
+    /// Returns the previous value of the setting
+    allow-forwarding-trace-context-headers: func(allow: bool) -> bool;
+
+    /// Represents a unit of work or operation
+    resource span {
+        /// Gets the starting time of the span
+        started-at: func() -> datetime;
+
+        /// Set an attribute on the span
+        set-attribute: func(name: string, value: attribute-value);
+
+        /// Set multiple attributes on the span
+        set-attributes: func(attributes: list<attribute>);
+
+        /// Early finishes the span; otherwise it will be finished when the resource is dropped
+        finish: func();
+    }
+
+    /// Represents an invocation context wich allows querying the stack of attributes
+    /// created by automatic and user-defined spans.
+    resource invocation-context {
+        /// Gets the current trace id
+        trace-id: func() -> trace-id;
+
+        /// Gets the current span id
+        span-id: func() -> span-id;
+
+        /// Gets the parent context, if any; allows recursive processing of the invocation context.
+        ///
+        /// Alternatively, the attribute query methods can return inherited values without having to
+        /// traverse the stack manually.
+        parent: func() -> option<invocation-context>;
+
+        /// Gets the value of an attribute `key`. If `inherited` is true, the value is searched in the stack of spans,
+        /// otherwise only in the current span.
+        get-attribute: func(key: string, inherited: bool) -> option<attribute-value>;
+
+        /// Gets all attributes of the current invocation context. If `inherited` is true, it returns the merged set of attributes, each
+        /// key associated with the latest value found in the stack of spans.
+        get-attributes: func(inherited: bool) -> list<attribute>;
+
+        /// Gets the chain of attribute values associated with the given `key`. If the key does not exist in any of the
+        /// spans in the invocation context, the list is empty. The chain's first element contains the most recent (innermost) value.
+        get-attribute-chain: func(key: string) -> list<attribute-value>;
+
+        /// Gets all values of all attributes of the current invocation context.
+        get-attribute-chains: func() -> list<attribute-chain>;
+
+        /// Gets the W3C Trace Context headers associated with the current invocation context
+        trace-context-headers: func() -> list<tuple<string, string>>;
+    }
+
+    /// An attribute of a span
+    record attribute {
+        key: string,
+        value: attribute-value
+    }
+
+    /// A chain of attribute values, the first element representing the most recent value
+    record attribute-chain {
+        key: string,
+        values: list<attribute-value>
+    }
+
+    /// Possible span attribute value types
+    variant attribute-value {
+        /// A string value
+        %string(string)
+    }
+
+    /// The trace represented by a 16 bytes hexadecimal string
+    type trace-id = string;
+
+    /// The span represented by a 8 bytes hexadecimal string
+    type span-id = string;
+}
diff --git a/sdks/go/golem/wit/deps/golem-1.x/golem-host.wit b/sdks/go/golem/wit/deps/golem-1.x/golem-host.wit
new file mode 100644
index 0000000000..ac94d44384
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-1.x/golem-host.wit
@@ -0,0 +1,340 @@
+package golem:api@1.5.0;
+
+/// The Golem host API provides low level access to Golem specific features such as promises and control over
+/// the durability and transactional guarantees the executor provides.
+interface host {
+    use golem:core/types@2.0.0.{component-id, card-id, uuid, agent-id, promise-id, oplog-index};
+    /// Represents a Golem component's version
+    type component-revision = u64;
+
+    /// Represents a Golem environment
+    record environment-id {
+      uuid: uuid,
+    }
+
+    /// Configurable persistence level for agents
+    variant persistence-level {
+        persist-nothing,
+        persist-remote-side-effects,
+        smart
+    }
+
+    /// Describes how to update an agent to a different component version
+    enum update-mode {
+        /// Automatic update tries to recover the agent using the new component version
+        /// and may fail if there is a divergence.
+        automatic,
+
+        /// Manual, snapshot-based update uses a user-defined implementation of the `save-snapshot` interface
+        /// to store the agent's state, and a user-defined implementation of the `load-snapshot` interface to
+        /// load it into the new version.
+        snapshot-based
+    }
+
+    /// Operators used in filtering enumerated agents
+    enum filter-comparator {
+        equal,
+        not-equal,
+        greater-equal,
+        greater,
+        less-equal,
+        less
+    }
+
+    /// Operators used on strings in filtering enumerated agents
+    enum string-filter-comparator {
+        equal,
+        not-equal,
+        like,
+        not-like,
+        starts-with
+    }
+
+    /// The current status of an agent
+    enum agent-status {
+        /// The agent is running an invoked function
+        running,
+        /// The agent is ready to run an invoked function
+        idle,
+        /// An invocation is active but waiting for something (sleeping, waiting for a promise)
+        suspended,
+        /// The last invocation was interrupted but will be resumed
+        interrupted,
+        /// The last invocation failed and a retry was scheduled
+        retrying,
+        /// The last invocation failed and the agent can no longer be used
+        failed,
+        /// The agent exited after a successful invocation and can no longer be invoked
+        exited,
+    }
+
+    /// Describes a filter condition on agent IDs when enumerating agents
+    record agent-name-filter {
+        comparator: string-filter-comparator,
+        value: string
+    }
+
+    /// Describes a filter condition on the agent status when enumerating agents
+    record agent-status-filter {
+        comparator: filter-comparator,
+        value: agent-status
+    }
+
+    /// Describes a filter condition on the component version when enumerating agents
+    record agent-version-filter {
+        comparator: filter-comparator,
+        value: u64
+    }
+
+    /// Describes a filter condition on the agent's creation time when enumerating agents
+    record agent-created-at-filter {
+        comparator: filter-comparator,
+        value: u64
+    }
+
+    /// Describes a filter condition on the agent's environment variables when enumerating agents
+    record agent-env-filter {
+        name: string,
+        comparator: string-filter-comparator,
+        value: string
+    }
+
+    /// Describes a filter condition on the agent's configuration variables when enumerating agents
+    record agent-config-vars-filter {
+        name: string,
+        comparator: string-filter-comparator,
+        value: string
+    }
+
+    /// Describes one filter condition for enumerating agents
+    variant agent-property-filter {
+        name(agent-name-filter),
+        status(agent-status-filter),
+        version(agent-version-filter),
+        created-at(agent-created-at-filter),
+        env(agent-env-filter),
+        config(agent-config-vars-filter)
+    }
+
+    /// Combines multiple filter conditions with an `AND` relationship for enumerating agents
+    record agent-all-filter {
+        filters: list<agent-property-filter>
+    }
+
+    /// Combines multiple groups of filter conditions with an `OR` relationship for enumerating agents
+    record agent-any-filter {
+        filters: list<agent-all-filter>
+    }
+
+    /// Metadata about an agent
+    record agent-metadata {
+        /// The agent ID, consists of the component ID, agent type and agent parameters
+        agent-id: agent-id,
+        /// Command line arguments seen by the agent
+        args: list<string>,
+        /// Environment variables seen by the agent
+        env: list<tuple<string, string>>,
+        /// Configuration variables seen by the agent
+        config: list<tuple<string, string>>,
+        /// The current agent status
+        status: agent-status,
+        /// The component version the agent is running with
+        component-revision: u64,
+        /// The agent's current retry count
+        retry-count: u64,
+        /// The environment the agent belongs to
+        environment-id: environment-id
+    }
+
+    /// Creates an agent enumeration
+    resource get-agents {
+        /// Creates an agent enumeration request. It is going to enumerate all agents of all the agent types
+        /// defined in `component-id`, filtered by the conditions given by `filter`. If `precise` is true,
+        /// the server will calculate the most recent state of all the returned agents, otherwise the returned
+        /// metadata will be not guaranteed to be up-to-date.
+        constructor(component-id: component-id, filter: option<agent-any-filter>, precise: bool);
+
+        /// Retrieves the next batch of agent metadata.
+        get-next: func() -> option<list<agent-metadata>>;
+    }
+
+    /// Target parameter for the `revert-agent` operation
+    variant revert-agent-target {
+        /// Revert to a specific oplog index. The given index will be the last one to be kept.
+        revert-to-oplog-index(oplog-index),
+        /// Revert the last N invocations.
+        revert-last-invocations(u64)
+    }
+
+    /// Details about the fork result
+    record fork-details {
+        forked-phantom-id: uuid,
+    }
+
+    /// Indicates which agent the code is running on after `fork`.
+    /// The parameter contains details about the fork result, such as the phantom-ID of the newly
+    /// created agent.
+    variant fork-result {
+        /// The original agent that called `fork`
+        original(fork-details),
+        /// The new agent
+        forked(fork-details)
+    }
+
+    resource get-promise-result {
+      /// Awaits the result of the promise.
+      get: async func() -> list<u8>;
+    }
+
+    /// Plain-data handle to a permission card visible to the guest.
+    record card {
+        card-id: card-id,
+    }
+
+    enum card-install-error {
+        revoked,
+        not-found,
+        not-permitted,
+    }
+
+    /// Create a new promise
+    create-promise: func() -> promise-id;
+
+    /// Gets a handle to the result of the promise. Can only be called in the same agent that orignally created the promise.
+    get-promise: func(promise-id: promise-id) -> get-promise-result;
+
+    /// Completes the given promise with the given payload. Returns true if the promise was completed, false
+    /// if the promise was already completed. The payload is passed to the agent that is awaiting the promise.
+    complete-promise: func(promise-id: promise-id, data: list<u8>) -> bool;
+
+    /// Returns the current position in the persistent op log
+    get-oplog-index: func() -> oplog-index;
+
+    /// Makes the current agent travel back in time and continue execution from the given position in the persistent
+    /// op log.
+    set-oplog-index: func(oplog-idx: oplog-index);
+
+    /// Blocks the execution until the oplog has been written to at least the specified number of replicas,
+    /// or the maximum number of replicas if the requested number is higher.
+    oplog-commit: func(replicas: u8);
+
+    /// Marks the beginning of an atomic operation.
+    /// In case of a failure within the region selected by `mark-begin-operation` and `mark-end-operation`
+    /// the whole region will be reexecuted on retry.
+    /// The end of the region is when `mark-end-operation` is called with the returned oplog-index.
+    mark-begin-operation: func() -> oplog-index;
+
+    /// Commits this atomic operation. After `mark-end-operation` is called for a given index, further calls
+    /// with the same parameter will do nothing.
+    mark-end-operation: func(begin: oplog-index);
+
+    /// Unconditionally traps the current invocation with the given reason.
+    ///
+    /// This call never returns: it surfaces as an uncatchable wasm trap on the host side
+    /// and the worker enters the standard trap-recovery flow. SDK guard helpers use this
+    /// to guarantee that a failed atomic region always leads to a trap, regardless of
+    /// whether the guest language could otherwise catch the failure.
+    trap: func(reason: string);
+
+    /// Gets the agent's current persistence level.
+    get-oplog-persistence-level: func() -> persistence-level;
+
+    /// Sets the agent's current persistence level. This can increase the performance of execution in cases where durable
+    /// execution is not required.
+    set-oplog-persistence-level: func(new-persistence-level: persistence-level);
+
+    /// Gets the current idempotence mode. See `set-idempotence-mode` for details.
+    get-idempotence-mode: func() -> bool;
+
+    /// Sets the current idempotence mode. The default is true.
+    /// True means side-effects are treated idempotent and Golem guarantees at-least-once semantics.
+    /// In case of false the executor provides at-most-once semantics, failing the agent in case it is
+    /// not known if the side effect was already executed.
+    set-idempotence-mode: func(idempotent: bool);
+
+    /// Generates an idempotency key. This operation will never be replayed —
+    /// i.e. not only is this key generated, but it is persisted and committed, such that the key can be used in third-party systems (e.g. payment processing)
+    /// to introduce idempotence.
+    generate-idempotency-key: func() -> uuid;
+
+    /// Returns one permission card currently installed in this agent's wallet, if any.
+    self-card: func() -> option<card>;
+
+    /// Derives a card handle from an installed card. This minimal test-facing form keeps the card as plain data.
+    derive-card: func(card: card) -> result<card, string>;
+
+    /// Installs a card into this agent's own wallet.
+    install-card: func(card: card) -> result<_, card-install-error>;
+
+    /// Initiates an update attempt for the given agent. The function returns immediately once the request has been processed,
+    /// not waiting for the agent to get updated.
+    update-agent:  func(agent-id: agent-id, target-revision: component-revision, mode: update-mode);
+
+    /// Get the current agent's metadata
+    get-self-metadata: func() -> agent-metadata;
+
+    /// Get agent metadata
+    get-agent-metadata: func(agent-id: agent-id) -> option<agent-metadata>;
+
+    /// Fork an agent to another agent at a given oplog index
+    fork-agent: func(source-agent-id: agent-id, target-agent-id: agent-id, oplog-idx-cut-off: oplog-index);
+
+    /// Revert an agent to a previous state
+    revert-agent: func(agent-id: agent-id, revert-target: revert-agent-target);
+
+    /// Get the component-id for a given component reference.
+    /// Returns none when no component with the specified reference exists.
+    /// The syntax of the component reference is implementation dependent.
+    ///
+    /// Golem OSS: "{component_name}"
+    /// Golem Cloud:
+    ///     1: "{component_name}" -> will resolve in current account and project
+    ///     2: "{project_name}/{component_name}" -> will resolve in current account
+    ///     3: "{account_id}/{project_name}/{component_name}"
+    resolve-component-id: func(component-reference: string) -> option<component-id>;
+
+    /// Get the agent-id for a given component and agent name.
+    /// Returns none when no component for the specified reference exists.
+    resolve-agent-id: func(component-reference: string, agent-name: string) -> option<agent-id>;
+
+    /// Get the agent-id for a given component and agent-name.
+    /// Returns none when no component for the specified component-reference or no agent with the specified agent-name exists.
+    resolve-agent-id-strict: func(component-reference: string, agent-name: string) -> option<agent-id>;
+
+    /// Forks the current agent at the current execution point. The new agent gets the same base agent ID but
+    /// with a new unique phantom ID. The phantom ID of the forked agent is returned in `fork-result` on
+    /// both sides. The newly created agent continues running from the same point, but the return value is
+    /// going to be different in this agent and the forked agent.
+    fork: func() -> fork-result;
+
+    /// Snapshot payload
+    record snapshot {
+        payload: list<u8>,
+        mime-type: string
+    }
+}
+
+/// Interface providing user-defined snapshotting capability. This can be used to perform manual update of agents
+/// when the new component incompatible with the old one.
+interface save-snapshot {
+    use host.{snapshot};
+
+    /// Saves the component's state into a user-defined snapshot
+    save: async func() -> snapshot;
+}
+
+/// Interface providing user-defined snapshotting capability. This can be used to perform manual update of agents
+/// when the new component incompatible with the old one.
+interface load-snapshot {
+    use host.{snapshot};
+
+    /// Tries to load a user-defined snapshot, setting up the agent's state based on it.
+    /// The function can return with a failure to indicate that the update is not possible.
+    load: async func(snapshot: snapshot) -> result<_, string>;
+}
+
+world golem-host {
+    import host;
+    import save-snapshot;
+    import load-snapshot;
+}
diff --git a/sdks/go/golem/wit/deps/golem-1.x/golem-oplog-processor.wit b/sdks/go/golem/wit/deps/golem-1.x/golem-oplog-processor.wit
new file mode 100644
index 0000000000..2478c3fdeb
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-1.x/golem-oplog-processor.wit
@@ -0,0 +1,27 @@
+package golem:api@1.5.0;
+
+interface oplog-processor {
+    use wasi:clocks/system-clock@0.3.0.{instant as datetime};
+    use golem:core/types@2.0.0.{account-id, component-id, agent-id};
+
+    use host.{oplog-index, agent-metadata};
+    use oplog.{oplog-entry};
+
+    record account-info {
+        account-id: account-id
+    }
+
+    /// Called when one of the agents the plugin is activated on has written new entries to its oplog.
+    ///
+    /// There are no guarantees for the number of processors running at the same time, and different entries from the same agent
+    /// may be sent to different processor instances.
+    ///
+    /// The `account-info` parameters contains details of the account the installation belongs to.
+    /// The `config` parameter contains the configuration parameters for the plugin, as specified in the plugin installation
+    /// The `component-id` parameter contains the identifier of the component the plugin was installed to.
+    /// The `agent-id` parameter identifies the agent.
+    /// The `metadata` parameter contains the latest metadata of the agent.
+    /// The `first-entry-index` parameter contains the index of the first entry in the list of `entries`.
+    /// The `entries` parameter always contains at least one element.
+    process: async func(account-info: account-info, config: list<tuple<string, string>>, component-id: component-id, agent-id: agent-id, metadata: agent-metadata, first-entry-index: oplog-index, entries: list<oplog-entry>) -> result<_, string>;
+}
diff --git a/sdks/go/golem/wit/deps/golem-1.x/golem-oplog.wit b/sdks/go/golem/wit/deps/golem-1.x/golem-oplog.wit
new file mode 100644
index 0000000000..96aa399631
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-1.x/golem-oplog.wit
@@ -0,0 +1,977 @@
+package golem:api@1.5.0;
+
+/// Host interface for enumerating and searching for agent oplogs
+interface oplog {
+    use wasi:clocks/system-clock@0.3.0.{instant as datetime};
+    use golem:core/types@2.0.0.{account-id, card-id, schema-value-tree, typed-schema-value};
+
+    use host.{component-revision, oplog-index, persistence-level, environment-id, uuid, agent-id, snapshot};
+    use wasi:clocks/types@0.3.0.{duration};
+
+    /// Whether an agent is durable (persistent oplog) or ephemeral.
+    /// This mirrors the agent-mode enum in golem:agent/common@1.5.0; it is duplicated here to avoid
+    /// a circular WIT package dependency between golem:api and golem:agent.
+    enum agent-mode {
+        durable,
+        ephemeral
+    }
+
+    use context.{attribute, attribute-value, span-id, trace-id};
+    use retry.{retry-predicate, retry-policy, named-retry-policy};
+
+    /// Index into a retry-policy-state's node list
+    type state-node-index = s32;
+
+    /// Persistent state of a retry policy across retry attempts.
+    /// Root is nodes[0]. Children referenced by state-node-index.
+    record retry-policy-state {
+        nodes: list<state-node>,
+    }
+
+    variant state-node {
+        /// Counter-based state (e.g. periodic, exponential, fibonacci).
+        counter(u32),
+        /// Terminal state — policy has given up.
+        terminal,
+        /// Wrapper state delegating to an inner policy state.
+        wrapper(state-node-index),
+        /// Count-box state with attempt tracking.
+        count-box(count-box-state),
+        /// And-then sequential composition state.
+        and-then(and-then-state),
+        /// Pair state for union/intersect composition.
+        pair(pair-state),
+    }
+
+    record count-box-state {
+        attempts: u32,
+        inner: state-node-index,
+    }
+
+    record and-then-state {
+        left: state-node-index,
+        right: state-node-index,
+        on-right: bool,
+    }
+
+    record pair-state {
+        left: state-node-index,
+        right: state-node-index,
+    }
+
+    record environment-plugin-grant-id {
+        uuid: uuid,
+    }
+
+    variant wrapped-function-type {
+        /// The side-effect reads from the agent's local state (for example local file system,
+        /// random generator, etc.)
+        read-local,
+        /// The side-effect writes to the agent's local state (for example local file system)
+        write-local,
+        /// The side-effect reads from external state (for example a key-value store)
+        read-remote,
+        /// The side-effect manipulates external state (for example an RPC call)
+        write-remote,
+        /// The side-effect manipulates external state through multiple invoked functions (for example
+        /// a HTTP request where reading the response involves multiple host function calls)
+        ///
+        /// On the first invocation of the batch, the parameter should be `None` - this triggers
+        /// writing a scope `Start` entry in the oplog. Followup invocations should contain this
+        /// entry's index as the parameter so their host-call `Start` entries can point back to the
+        /// scope. In batched remote writes it is the caller's responsibility to manually write the
+        /// matching scope `End` entry (using `end_function`) when the operation is completed.
+        write-remote-batched(option<oplog-index>),
+        write-remote-transaction(option<oplog-index>)
+    }
+
+    record plugin-installation-description {
+        environment-plugin-grant-id: environment-plugin-grant-id,
+        plugin-priority: s32,
+        plugin-name: string,
+        plugin-version: string,
+        parameters: list<tuple<string, string>>
+    }
+
+    record raw-local-agent-config-entry {
+        path: list<string>,
+        value: schema-value-tree
+    }
+
+    record local-agent-config-entry {
+        path: list<string>,
+        value: typed-schema-value
+    }
+
+    record create-parameters {
+        timestamp: datetime,
+        agent-id: agent-id,
+        agent-mode: agent-mode,
+        component-revision: component-revision,
+        env: list<tuple<string, string>>,
+        created-by: account-id,
+        environment-id: environment-id,
+        parent: option<agent-id>,
+        component-size: u64,
+        initial-total-linear-memory-size: u64,
+        initial-active-plugins: list<plugin-installation-description>,
+        local-agent-config: list<local-agent-config-entry>,
+        original-phantom-id: option<uuid>,
+        instance-id: uuid
+    }
+
+    /// Parameters of an enriched durable host-call `start` entry.
+    ///
+    /// The recorded `request` payload of every durable host call — including
+    /// durable P3 async calls such as HTTP send/consume-body, sockets, keyvalue,
+    /// and blobstore operations — surfaces as a generic `typed-schema-value`
+    /// tree, identified by `function-name`; there are no per-interface named WIT
+    /// variants for the payload shapes.
+    record start-parameters {
+        timestamp: datetime,
+        parent-start-index: option<oplog-index>,
+        function-name: string,
+        request: option<typed-schema-value>,
+        durable-function-type: wrapped-function-type,
+    }
+
+    /// Parameters of an enriched durable host-call `end` entry. Like the
+    /// `start` `request`, the recorded `response` payload surfaces as a generic
+    /// `typed-schema-value` tree (no per-interface named WIT variants).
+    record end-parameters {
+        timestamp: datetime,
+        start-index: oplog-index,
+        response: option<typed-schema-value>,
+        forced-commit: bool,
+    }
+
+    /// Parameters of an enriched durable host-call `cancelled` entry. Like the
+    /// `start` `request`, the optional recorded `partial` result surfaces as a
+    /// generic `typed-schema-value` tree (no per-interface named WIT variants).
+    record cancelled-parameters {
+        timestamp: datetime,
+        start-index: oplog-index,
+        partial: option<typed-schema-value>,
+    }
+
+    /// Parameters of a `completion-discarded` entry: the durable host call started at
+    /// `start-index` completed successfully (its `end` entry was persisted) but the response
+    /// was never delivered to the agent, because the agent dropped the call's completion
+    /// future after the `end` was already recorded.
+    record completion-discarded-parameters {
+        timestamp: datetime,
+        start-index: oplog-index,
+    }
+
+    record local-span-data {
+        span-id: span-id,
+        start: datetime,
+        parent: option<span-id>,
+        /// Optionally an index of the invocation-context field within agent-invocation
+        linked-context: option<u64>,
+        attributes: list<attribute>,
+        inherited: bool
+    }
+
+    record external-span-data {
+        span-id: span-id
+    }
+
+    variant span-data {
+        local-span(local-span-data),
+        external-span(external-span-data)
+    }
+
+    record agent-invocation-started-parameters {
+        timestamp: datetime,
+        invocation: agent-invocation,
+    }
+
+    record agent-invocation-finished-parameters {
+        timestamp: datetime,
+        %result: agent-invocation-result,
+        method-name: option<string>,
+        consumed-fuel: s64,
+        component-revision: u64,
+    }
+
+    record error-parameters {
+        timestamp: datetime,
+        error: string,
+        retry-from: oplog-index,
+        inside-atomic-region: bool,
+        /// Persistent retry policy state, if a semantic retry policy is active.
+        retry-policy-state: option<retry-policy-state>,
+    }
+
+    record oplog-region {
+        start: oplog-index,
+        end: oplog-index
+    }
+
+    record jump-parameters {
+        timestamp: datetime,
+        jump: oplog-region
+    }
+
+    /// Parameters for a set-retry-policy oplog entry.
+    record set-retry-policy-parameters {
+        timestamp: datetime,
+        policy: named-retry-policy,
+    }
+
+    /// Parameters for a remove-retry-policy oplog entry.
+    record remove-retry-policy-parameters {
+        timestamp: datetime,
+        name: string,
+    }
+
+    record queued-card-event-install {
+        card-id: card-id,
+    }
+
+    record queued-card-event-revoke {
+        card-id: card-id,
+    }
+
+    variant queued-card-event {
+        install(queued-card-event-install),
+        revoke(queued-card-event-revoke),
+    }
+
+    /// Parameters for a card-event-queued oplog entry.
+    record card-event-queued-parameters {
+        timestamp: datetime,
+        event: queued-card-event,
+    }
+
+    /// Parameters for a card-installed oplog entry.
+    record card-installed-parameters {
+        timestamp: datetime,
+        queued-event-index: option<oplog-index>,
+        card-id: card-id,
+    }
+
+    /// Raw parameters for a card-installed oplog entry.
+    record raw-card-installed-parameters {
+        timestamp: datetime,
+        queued-event-index: option<oplog-index>,
+        card: list<u8>,
+    }
+
+    enum card-install-failure {
+        card-revoked,
+        not-found,
+        recipient-mismatch,
+        not-permitted,
+    }
+
+    /// Parameters for a card-install-failed oplog entry.
+    record card-install-failed-parameters {
+        timestamp: datetime,
+        queued-event-index: oplog-index,
+        card-id: card-id,
+        reason: card-install-failure,
+    }
+
+    /// Parameters for a card-revoked oplog entry.
+    record card-revoked-parameters {
+        timestamp: datetime,
+        queued-event-index: oplog-index,
+        card-id: card-id,
+    }
+
+    /// Parameters for a card-expired oplog entry.
+    record card-expired-parameters {
+        timestamp: datetime,
+        card-id: card-id,
+    }
+
+    /// Identifies which host-owned stream a host-stream-frame oplog entry belongs to.
+    /// The kind determines how the entry's payload is interpreted.
+    enum host-stream-kind {
+        /// A frame of the outgoing request body of a P3 HTTP client send.
+        p3-http-request-body,
+    }
+
+    /// Parameters for a host-stream-frame oplog entry: a durably recorded frame of a
+    /// host-owned stream (e.g. the outgoing request body of a P3 HTTP client send),
+    /// attached to the durable host call identified by its start entry's index.
+    record host-stream-frame-parameters {
+        timestamp: datetime,
+        parent-start-index: oplog-index,
+        kind: host-stream-kind,
+        payload: typed-schema-value,
+    }
+
+    record end-atomic-region-parameters {
+        timestamp: datetime,
+        begin-index: oplog-index
+    }
+
+    record agent-initialization-parameters {
+        idempotency-key: string,
+        constructor-parameters: typed-schema-value,
+        trace-id: string,
+        trace-states: list<string>,
+        invocation-context: list<list<span-data>>,
+    }
+
+    record agent-method-invocation-parameters {
+        idempotency-key: string,
+        method-name: string,
+        function-input: typed-schema-value,
+        trace-id: string,
+        trace-states: list<string>,
+        invocation-context: list<list<span-data>>,
+    }
+
+    record load-snapshot-parameters {
+        snapshot: snapshot-data,
+    }
+
+    record process-oplog-entries-parameters {
+        idempotency-key: string,
+    }
+
+    record manual-update-parameters {
+        target-revision: component-revision,
+    }
+
+    variant agent-invocation {
+        agent-initialization(agent-initialization-parameters),
+        agent-method-invocation(agent-method-invocation-parameters),
+        save-snapshot,
+        load-snapshot(load-snapshot-parameters),
+        process-oplog-entries(process-oplog-entries-parameters),
+        manual-update(manual-update-parameters),
+    }
+
+    variant agent-invocation-result {
+        agent-initialization(agent-invocation-output-parameters),
+        agent-method(agent-invocation-output-parameters),
+        manual-update,
+        load-snapshot(fallible-result-parameters),
+        save-snapshot(save-snapshot-result-parameters),
+        process-oplog-entries(fallible-result-parameters),
+    }
+
+    record agent-invocation-output-parameters {
+        output: typed-schema-value,
+    }
+
+    record fallible-result-parameters {
+        error: option<string>,
+    }
+
+    record save-snapshot-result-parameters {
+        snapshot: snapshot-data,
+    }
+
+    record pending-agent-invocation-parameters {
+        timestamp: datetime,
+        invocation: agent-invocation
+    }
+
+    variant update-description {
+        /// Automatic update by replaying the oplog on the new version
+        auto-update,
+        /// Custom update by loading a given snapshot on the new version
+        snapshot-based(snapshot)
+    }
+
+    record pending-update-parameters {
+        timestamp: datetime,
+        target-revision: component-revision,
+        description: update-description
+    }
+
+    record successful-update-parameters {
+        timestamp: datetime,
+        target-revision: component-revision,
+        new-component-size: u64,
+        new-active-plugins: list<plugin-installation-description>
+    }
+
+    record failed-update-parameters {
+        timestamp: datetime,
+        target-revision: component-revision,
+        details: option<string>
+    }
+
+    record grow-memory-parameters {
+        timestamp: datetime,
+        delta: u64
+    }
+
+    record filesystem-storage-usage-update-parameters {
+        timestamp: datetime,
+        delta: s64
+    }
+
+    type agent-resource-id = u64;
+
+    record create-resource-parameters {
+        timestamp: datetime,
+        id: agent-resource-id,
+        name: string,
+        owner: string
+    }
+
+    record drop-resource-parameters {
+        timestamp: datetime,
+        id: agent-resource-id,
+        name: string,
+        owner: string
+    }
+
+    enum log-level {
+        stdout,
+        stderr,
+        trace,
+        debug,
+        info,
+        warn,
+        error,
+        critical
+    }
+
+    record log-parameters {
+        timestamp: datetime,
+        level: log-level,
+        context: string,
+        message: string
+    }
+
+    record activate-plugin-parameters {
+        timestamp: datetime,
+        plugin: plugin-installation-description
+    }
+
+    record deactivate-plugin-parameters {
+        timestamp: datetime,
+        plugin: plugin-installation-description
+    }
+
+    record revert-parameters {
+        timestamp: datetime,
+        dropped-region: oplog-region
+    }
+
+    record cancel-pending-invocation-parameters {
+        timestamp: datetime,
+        idempotency-key: string
+    }
+
+    record start-span-parameters {
+        timestamp: datetime,
+        span-id: span-id,
+        parent: option<span-id>,
+        linked-context-id: option<span-id>,
+        attributes: list<attribute>,
+    }
+
+    record finish-span-parameters {
+        timestamp: datetime,
+        span-id: span-id
+    }
+
+    record set-span-attribute-parameters {
+        timestamp: datetime,
+        span-id: span-id,
+        key: string,
+        value: attribute-value
+    }
+
+    record change-persistence-level-parameters {
+        timestamp: datetime,
+        persistence-level: persistence-level
+    }
+
+    record begin-remote-transaction-parameters {
+        timestamp: datetime,
+        transaction-id: string
+    }
+
+    record remote-transaction-parameters {
+        timestamp: datetime,
+        begin-index: oplog-index
+    }
+
+    record snapshot-data {
+        data: list<u8>,
+        mime-type: string,
+    }
+
+    record snapshot-parameters {
+        timestamp: datetime,
+        data: snapshot-data,
+    }
+
+    record oplog-processor-checkpoint-parameters {
+        timestamp: datetime,
+        plugin: plugin-installation-description,
+        target-agent-id: agent-id,
+        confirmed-up-to: oplog-index,
+        sending-up-to: oplog-index,
+        last-batch-start: oplog-index,
+    }
+
+    record timestamp {
+        timestamp: datetime
+    }
+
+    /// Opaque oplog payload, which can either be serialized inline or stored externally
+    variant oplog-payload {
+        inline(list<u8>),
+        external(oplog-external-payload)
+    }
+
+    record oplog-external-payload {
+        payload-id: uuid,
+        md5-hash: list<u8>
+    }
+
+    record agent-terminated-by-quota-error {
+        environment-id: environment-id,
+        resource-name: string
+    }
+
+    record ephemeral-sleep-too-long {
+        requested-nanos: u64,
+        max-nanos: u64
+    }
+
+    record ephemeral-fuel-exhausted {
+        overdraft-limit: u64
+    }
+
+    record ephemeral-cannot-suspend {
+        reason: string
+    }
+
+    record read-only-violation {
+        method: string,
+        host-function: string
+    }
+
+    /// Describes the error that occurred in the agent
+    variant worker-error {
+        unknown(string),
+        invalid-request(string),
+        stack-overflow,
+        out-of-memory,
+        exceeded-memory-limit,
+        internal-error(string),
+        deterministic-trap(string),
+        transient-error(string),
+        permanent-error(string),
+        exceeded-table-limit,
+        exceeded-http-call-limit,
+        exceeded-rpc-call-limit,
+        node-out-of-filesystem-storage,
+        agent-exceeded-filesystem-storage-limit,
+        agent-terminated-by-quota(agent-terminated-by-quota-error),
+        ephemeral-sleep-too-long(ephemeral-sleep-too-long),
+        ephemeral-fuel-exhausted(ephemeral-fuel-exhausted),
+        ephemeral-cannot-suspend(ephemeral-cannot-suspend),
+        read-only-violation(read-only-violation)
+    }
+
+    record raw-create-parameters {
+        timestamp: datetime,
+        agent-id: agent-id,
+        agent-mode: agent-mode,
+        component-revision: component-revision,
+        env: list<tuple<string, string>>,
+        environment-id: environment-id,
+        created-by: account-id,
+        parent: option<agent-id>,
+        component-size: u64,
+        initial-total-linear-memory-size: u64,
+        initial-active-plugins: list<environment-plugin-grant-id>,
+        local-agent-config: list<raw-local-agent-config-entry>,
+        original-phantom-id: option<uuid>,
+        instance-id: uuid
+    }
+
+    record raw-start-parameters {
+        timestamp: datetime,
+        parent-start-index: option<oplog-index>,
+        function-name: string,
+        request: option<oplog-payload>,
+        durable-function-type: wrapped-function-type,
+    }
+
+    record raw-end-parameters {
+        timestamp: datetime,
+        start-index: oplog-index,
+        response: option<oplog-payload>,
+        forced-commit: bool,
+    }
+
+    record raw-cancelled-parameters {
+        timestamp: datetime,
+        start-index: oplog-index,
+        partial: option<oplog-payload>,
+    }
+
+    record raw-completion-discarded-parameters {
+        timestamp: datetime,
+        start-index: oplog-index,
+    }
+
+    /// Parameters for a host-stream-frame oplog entry, with the frame payload in raw
+    /// (possibly externally stored) form.
+    record raw-host-stream-frame-parameters {
+        timestamp: datetime,
+        parent-start-index: oplog-index,
+        kind: host-stream-kind,
+        payload: oplog-payload,
+    }
+
+    record raw-agent-invocation-started-parameters {
+        timestamp: datetime,
+        idempotency-key: string,
+        payload: oplog-payload,
+        trace-id: string,
+        trace-states: list<string>,
+        invocation-context: list<span-data>,
+    }
+
+    record raw-agent-invocation-finished-parameters {
+        timestamp: datetime,
+        %result: oplog-payload,
+        method-name: option<string>,
+        consumed-fuel: s64,
+        component-revision: u64,
+    }
+
+    record raw-error-parameters {
+        timestamp: datetime,
+        error: worker-error,
+        retry-from: oplog-index,
+        inside-atomic-region: bool,
+        /// Persistent retry policy state, if a semantic retry policy is active.
+        retry-policy-state: option<retry-policy-state>,
+    }
+
+    record raw-pending-agent-invocation-parameters {
+        timestamp: datetime,
+        idempotency-key: string,
+        payload: oplog-payload,
+        trace-id: string,
+        trace-states: list<string>,
+        invocation-context: list<span-data>,
+    }
+
+    /// Raw update description used in oplog entries
+    variant raw-update-description {
+        /// Automatic update by replaying the oplog on the new version
+        automatic(component-revision),
+        /// Custom update by loading a given snapshot on the new version
+        snapshot-based(raw-snapshot-based-update)
+    }
+
+    record raw-snapshot-based-update {
+        target-revision: component-revision,
+        payload: oplog-payload,
+        mime-type: string
+    }
+
+    record raw-pending-update-parameters {
+        timestamp: datetime,
+        description: raw-update-description
+    }
+
+    record raw-successful-update-parameters {
+        timestamp: datetime,
+        target-revision: component-revision,
+        new-component-size: u64,
+        new-active-plugins: list<environment-plugin-grant-id>
+    }
+
+    record resource-type-id {
+        name: string,
+        owner: string,
+    }
+
+    record raw-create-resource-parameters {
+        timestamp: datetime,
+        id: agent-resource-id,
+        resource-type-id: resource-type-id,
+    }
+
+    record raw-drop-resource-parameters {
+        timestamp: datetime,
+        id: agent-resource-id,
+        resource-type-id: resource-type-id,
+    }
+
+    record raw-activate-plugin-parameters {
+        timestamp: datetime,
+        plugin-grant-id: environment-plugin-grant-id
+    }
+
+    record raw-deactivate-plugin-parameters {
+        timestamp: datetime,
+        plugin-grant-id: environment-plugin-grant-id
+    }
+
+    record raw-begin-remote-transaction-parameters {
+        timestamp: datetime,
+        transaction-id: string,
+        original-begin-index: option<oplog-index>
+    }
+
+    record raw-snapshot-parameters {
+        timestamp: datetime,
+        data: oplog-payload,
+        mime-type: string
+    }
+
+    record raw-oplog-processor-checkpoint-parameters {
+        timestamp: datetime,
+        plugin-grant-id: environment-plugin-grant-id,
+        target-agent-id: agent-id,
+        confirmed-up-to: oplog-index,
+        sending-up-to: oplog-index,
+        last-batch-start: oplog-index,
+    }
+
+    variant oplog-entry {
+        /// The initial agent oplog entry
+        create(raw-create-parameters),
+        /// Marks the start of a durable host call (or scope such as a batched-write).
+        start(raw-start-parameters),
+        /// Marks the successful completion of a durable host call (or scope) started by a matching `Start`.
+        end(raw-end-parameters),
+        /// Marks that a durable host call started by a matching `Start` was cancelled
+        /// (e.g. dropped from a `select!`) before producing a final response.
+        cancelled(raw-cancelled-parameters),
+        /// The agent has been invoked
+        agent-invocation-started(raw-agent-invocation-started-parameters),
+        /// The agent has completed an invocation
+        agent-invocation-finished(raw-agent-invocation-finished-parameters),
+        /// Agent suspended
+        suspend(timestamp),
+        /// Agent failed
+        error(raw-error-parameters),
+        /// Marker entry added when get-oplog-index is called from the agent, to make the jumping behavior
+        /// more predictable.
+        no-op(timestamp),
+        /// The agent needs to recover up to the given target oplog index and continue running from
+        /// the source oplog index from there
+        /// `jump` is an oplog region representing that from the end of that region we want to go back to the start and
+        /// ignore all recorded operations in between.
+        jump(jump-parameters),
+        /// Indicates that the agent has been interrupted at this point.
+        /// Only used to recompute the agent's (cached) status, has no effect on execution.
+        interrupted(timestamp),
+        /// Indicates that the agent has been exited using WASI's exit function.
+        exited(timestamp),
+        /// Begins an atomic region. All oplog entries after `BeginAtomicRegion` are to be ignored during
+        /// recovery except if there is a corresponding `EndAtomicRegion` entry.
+        begin-atomic-region(timestamp),
+        /// Ends an atomic region. All oplog entries between the corresponding `BeginAtomicRegion` and this
+        /// entry are to be considered during recovery, and the begin/end markers can be removed during oplog
+        /// compaction.
+        end-atomic-region(end-atomic-region-parameters),
+        /// An invocation request arrived while the agent was busy
+        pending-agent-invocation(raw-pending-agent-invocation-parameters),
+        /// An update request arrived and will be applied as soon the agent restarts
+        pending-update(raw-pending-update-parameters),
+        /// An update was successfully applied
+        successful-update(raw-successful-update-parameters),
+        /// An update failed to be applied
+        failed-update(failed-update-parameters),
+        /// Increased total linear memory size
+        grow-memory(grow-memory-parameters),
+        /// Updated filesystem usage by a signed delta
+        filesystem-storage-usage-update(filesystem-storage-usage-update-parameters),
+        /// Created a resource instance
+        create-resource(raw-create-resource-parameters),
+        /// Dropped a resource instance
+        drop-resource(raw-drop-resource-parameters),
+        /// The agent emitted a log message
+        log(log-parameters),
+        /// The agent has been restarted, forgetting all its history
+        restart(timestamp),
+        /// Activates a plugin
+        activate-plugin(raw-activate-plugin-parameters),
+        /// Deactivates a plugin
+        deactivate-plugin(raw-deactivate-plugin-parameters),
+        /// Revert an agent to a previous state
+        revert(revert-parameters),
+        /// Cancel a pending invocation
+        cancel-pending-invocation(cancel-pending-invocation-parameters),
+        /// Start a new span in the invocation context
+        start-span(start-span-parameters),
+        /// Finish an open span in the invocation context
+        finish-span(finish-span-parameters),
+        /// Set an attribute on an open span in the invocation context
+        set-span-attribute(set-span-attribute-parameters),
+        /// Change the current persistence level
+        change-persistence-level(change-persistence-level-parameters),
+        /// Begins a transaction operation
+        begin-remote-transaction(raw-begin-remote-transaction-parameters),
+        /// Pre-Commit of the transaction, indicating that the transaction will be committed
+        pre-commit-remote-transaction(remote-transaction-parameters),
+        /// Pre-Rollback of the transaction, indicating that the transaction will be rolled back
+        pre-rollback-remote-transaction(remote-transaction-parameters),
+        /// Committed transaction operation, indicating that the transaction was committed
+        committed-remote-transaction(remote-transaction-parameters),
+        /// Rolled back transaction operation, indicating that the transaction was rolled back
+        rolled-back-remote-transaction(remote-transaction-parameters),
+        /// A snapshot of the agent's state
+        snapshot(raw-snapshot-parameters),
+        /// Checkpoint for oplog processor plugin delivery tracking
+        oplog-processor-checkpoint(raw-oplog-processor-checkpoint-parameters),
+        /// Sets or overwrites a named retry policy
+        set-retry-policy(set-retry-policy-parameters),
+        /// Removes a named retry policy by name
+        remove-retry-policy(remove-retry-policy-parameters),
+        /// Durable queue entry for pending permission-card work
+        card-event-queued(card-event-queued-parameters),
+        /// Records successful installation of a permission card into the agent wallet
+        card-installed(raw-card-installed-parameters),
+        /// Records failed installation of a permission card into the agent wallet
+        card-install-failed(card-install-failed-parameters),
+        /// Records that a permission card used by the agent has been revoked
+        card-revoked(card-revoked-parameters),
+        /// Records that a permission card used by the agent has expired
+        card-expired(card-expired-parameters),
+        /// A durably recorded frame of a host-owned stream (e.g. an outgoing HTTP request body),
+        /// attached to the durable host call identified by its start entry's index
+        host-stream-frame(raw-host-stream-frame-parameters),
+        /// The successful completion of the durable host call started by the matching `start`
+        /// was persisted, but its response was never delivered to the agent (the agent dropped
+        /// the completion future after the `end` was recorded)
+        completion-discarded(raw-completion-discarded-parameters)
+    }
+
+    variant public-oplog-entry {
+        /// The initial agent oplog entry
+        create(create-parameters),
+        /// Marks the start of a durable host call (or scope such as a batched-write).
+        start(start-parameters),
+        /// Marks the successful completion of a durable host call (or scope) started by a matching `Start`.
+        end(end-parameters),
+        /// Marks that a durable host call started by a matching `Start` was cancelled
+        /// (e.g. dropped from a `select!`) before producing a final response.
+        cancelled(cancelled-parameters),
+        /// The agent has been invoked
+        agent-invocation-started(agent-invocation-started-parameters),
+        /// The agent has completed an invocation
+        agent-invocation-finished(agent-invocation-finished-parameters),
+        /// Agent suspended
+        suspend(timestamp),
+        /// Agent failed
+        error(error-parameters),
+        /// Marker entry added when get-oplog-index is called from the agent, to make the jumping behavior
+        /// more predictable.
+        no-op(timestamp),
+        /// The agent needs to recover up to the given target oplog index and continue running from
+        /// the source oplog index from there
+        /// `jump` is an oplog region representing that from the end of that region we want to go back to the start and
+        /// ignore all recorded operations in between.
+        jump(jump-parameters),
+        /// Indicates that the agent has been interrupted at this point.
+        /// Only used to recompute the agent's (cached) status, has no effect on execution.
+        interrupted(timestamp),
+        /// Indicates that the agent has been exited using WASI's exit function.
+        exited(timestamp),
+        /// Begins an atomic region. All oplog entries after `BeginAtomicRegion` are to be ignored during
+        /// recovery except if there is a corresponding `EndAtomicRegion` entry.
+        begin-atomic-region(timestamp),
+        /// Ends an atomic region. All oplog entries between the corresponding `BeginAtomicRegion` and this
+        /// entry are to be considered during recovery, and the begin/end markers can be removed during oplog
+        /// compaction.
+        end-atomic-region(end-atomic-region-parameters),
+        /// An invocation request arrived while the agent was busy
+        pending-agent-invocation(pending-agent-invocation-parameters),
+        /// An update request arrived and will be applied as soon the agent restarts
+        pending-update(pending-update-parameters),
+        /// An update was successfully applied
+        successful-update(successful-update-parameters),
+        /// An update failed to be applied
+        failed-update(failed-update-parameters),
+        /// Increased total linear memory size
+        grow-memory(grow-memory-parameters),
+        /// Updated filesystem usage by a signed delta
+        filesystem-storage-usage-update(filesystem-storage-usage-update-parameters),
+        /// Created a resource instance
+        create-resource(create-resource-parameters),
+        /// Dropped a resource instance
+        drop-resource(drop-resource-parameters),
+        /// The agent emitted a log message
+        log(log-parameters),
+        /// The agent's has been restarted, forgetting all its history
+        restart(timestamp),
+        /// Activates a plugin
+        activate-plugin(activate-plugin-parameters),
+        /// Deactivates a plugin
+        deactivate-plugin(deactivate-plugin-parameters),
+        /// Revert an agent to a previous state
+        revert(revert-parameters),
+        /// Cancel a pending invocation
+        cancel-pending-invocation(cancel-pending-invocation-parameters),
+        /// Start a new span in the invocation context
+        start-span(start-span-parameters),
+        /// Finish an open span in the invocation context
+        finish-span(finish-span-parameters),
+        /// Set an attribute on an open span in the invocation context
+        set-span-attribute(set-span-attribute-parameters),
+        /// Change the current persistence level
+        change-persistence-level(change-persistence-level-parameters),
+        /// Begins a transaction operation
+        begin-remote-transaction(begin-remote-transaction-parameters),
+        /// Pre-Commit of the transaction, indicating that the transaction will be committed
+        pre-commit-remote-transaction(remote-transaction-parameters),
+        /// Pre-Rollback of the transaction, indicating that the transaction will be rolled back
+        pre-rollback-remote-transaction(remote-transaction-parameters),
+        /// Committed transaction operation, indicating that the transaction was committed
+        committed-remote-transaction(remote-transaction-parameters),
+        /// Rolled back transaction operation, indicating that the transaction was rolled back
+        rolled-back-remote-transaction(remote-transaction-parameters),
+        /// A snapshot of the worker's state
+        snapshot(snapshot-parameters),
+        /// Checkpoint for oplog processor plugin delivery tracking
+        oplog-processor-checkpoint(oplog-processor-checkpoint-parameters),
+        /// Sets or overwrites a named retry policy
+        set-retry-policy(set-retry-policy-parameters),
+        /// Removes a named retry policy by name
+        remove-retry-policy(remove-retry-policy-parameters),
+        /// Durable queue entry for pending permission-card work
+        card-event-queued(card-event-queued-parameters),
+        /// Records successful installation of a permission card into the agent wallet
+        card-installed(card-installed-parameters),
+        /// Records failed installation of a permission card into the agent wallet
+        card-install-failed(card-install-failed-parameters),
+        /// Records that a permission card used by the agent has been revoked
+        card-revoked(card-revoked-parameters),
+        /// Records that a permission card used by the agent has expired
+        card-expired(card-expired-parameters),
+        /// A durably recorded frame of a host-owned stream (e.g. an outgoing HTTP request body),
+        /// attached to the durable host call identified by its start entry's index
+        host-stream-frame(host-stream-frame-parameters),
+        /// The successful completion of the durable host call started by the matching `start`
+        /// was persisted, but its response was never delivered to the agent (the agent dropped
+        /// the completion future after the `end` was recorded)
+        completion-discarded(completion-discarded-parameters)
+    }
+
+    /// Enriches raw oplog entries into public oplog entries by resolving oplog payloads
+    /// and augmenting entries with component metadata.
+    enrich-oplog-entries: func(environment-id: environment-id, agent-id: agent-id, entries: list<tuple<oplog-index, oplog-entry>>, component-revision: component-revision) -> result<list<public-oplog-entry>, string>;
+
+    resource get-oplog {
+        constructor(agent-id: agent-id, start: oplog-index);
+        get-next: func() -> option<list<public-oplog-entry>>;
+    }
+
+    resource search-oplog {
+        constructor(agent-id: agent-id, text: string);
+        get-next: func() -> option<list<tuple<oplog-index, public-oplog-entry>>>;
+    }
+}
diff --git a/sdks/go/golem/wit/deps/golem-1.x/golem-retry.wit b/sdks/go/golem/wit/deps/golem-1.x/golem-retry.wit
new file mode 100644
index 0000000000..c585bbdbe0
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-1.x/golem-retry.wit
@@ -0,0 +1,165 @@
+package golem:api@1.5.0;
+
+interface retry {
+    use wasi:clocks/types@0.3.0.{duration};
+
+    // ── Predicate value ──────────────────────────────────────────────
+
+    /// Dynamic value for property comparisons in retry predicates
+    variant predicate-value {
+        text(string),
+        integer(s64),
+        boolean(bool),
+    }
+
+    // ── Predicate tree (flattened) ───────────────────────────────────
+
+    /// Index into a retry-predicate's node list
+    type predicate-node-index = s32;
+
+    /// A composable predicate tree for matching retry contexts.
+    /// Root is nodes[0]. Children referenced by predicate-node-index.
+    record retry-predicate {
+        nodes: list<predicate-node>,
+    }
+
+    variant predicate-node {
+        prop-eq(property-comparison),
+        prop-neq(property-comparison),
+        prop-gt(property-comparison),
+        prop-gte(property-comparison),
+        prop-lt(property-comparison),
+        prop-lte(property-comparison),
+        prop-exists(string),
+        prop-in(property-set-check),
+        prop-matches(property-pattern),
+        prop-starts-with(property-pattern),
+        prop-contains(property-pattern),
+        pred-and(tuple<predicate-node-index, predicate-node-index>),
+        pred-or(tuple<predicate-node-index, predicate-node-index>),
+        pred-not(predicate-node-index),
+        pred-true,
+        pred-false,
+    }
+
+    record property-comparison {
+        property-name: string,
+        value: predicate-value,
+    }
+
+    record property-set-check {
+        property-name: string,
+        values: list<predicate-value>,
+    }
+
+    record property-pattern {
+        property-name: string,
+        pattern: string,
+    }
+
+    // ── Policy tree (flattened) ──────────────────────────────────────
+
+    /// Index into a retry-policy's node list
+    type policy-node-index = s32;
+
+    /// A composable retry policy tree.
+    /// Root is nodes[0]. Children referenced by policy-node-index.
+    record retry-policy {
+        nodes: list<policy-node>,
+    }
+
+    variant policy-node {
+        periodic(duration),
+        exponential(exponential-config),
+        fibonacci(fibonacci-config),
+        immediate,
+        never,
+        count-box(count-box-config),
+        time-box(time-box-config),
+        clamp-delay(clamp-config),
+        add-delay(add-delay-config),
+        jitter(jitter-config),
+        filtered-on(filtered-config),
+        and-then(tuple<policy-node-index, policy-node-index>),
+        policy-union(tuple<policy-node-index, policy-node-index>),
+        policy-intersect(tuple<policy-node-index, policy-node-index>),
+    }
+
+    record exponential-config {
+        base-delay: duration,
+        factor: f64,
+    }
+
+    record fibonacci-config {
+        first: duration,
+        second: duration,
+    }
+
+    record count-box-config {
+        max-retries: u32,
+        inner: policy-node-index,
+    }
+
+    record time-box-config {
+        limit: duration,
+        inner: policy-node-index,
+    }
+
+    record clamp-config {
+        min-delay: duration,
+        max-delay: duration,
+        inner: policy-node-index,
+    }
+
+    record add-delay-config {
+        delay: duration,
+        inner: policy-node-index,
+    }
+
+    record jitter-config {
+        factor: f64,
+        inner: policy-node-index,
+    }
+
+    /// filtered-config embeds a full retry-predicate inline (self-contained)
+    record filtered-config {
+        predicate: retry-predicate,
+        inner: policy-node-index,
+    }
+
+    // ── Named policy rule ────────────────────────────────────────────
+
+    /// A named retry policy rule: predicate selects when it applies,
+    /// policy defines the retry strategy, priority controls evaluation order
+    /// (higher = checked first).
+    record named-retry-policy {
+        name: string,
+        priority: u32,
+        predicate: retry-predicate,
+        policy: retry-policy,
+    }
+
+    // ── Host functions ───────────────────────────────────────────────
+
+    /// Get all retry policies active for this agent
+    get-retry-policies: func() -> list<named-retry-policy>;
+
+    /// Get a specific retry policy by name
+    get-retry-policy-by-name: func(name: string) -> option<named-retry-policy>;
+
+    /// Resolve the matching retry policy for a given operation context.
+    /// Evaluates named policies in descending priority order; returns the
+    /// policy from the first rule whose predicate matches, or none.
+    resolve-retry-policy: func(
+        verb: string,
+        noun-uri: string,
+        properties: list<tuple<string, predicate-value>>,
+    ) -> option<retry-policy>;
+
+    /// Add or overwrite a named retry policy (persisted to oplog).
+    /// If a policy with the same name exists, it is replaced.
+    set-retry-policy: func(policy: named-retry-policy);
+
+    /// Remove a named retry policy by name (persisted to oplog).
+    remove-retry-policy: func(name: string);
+}
diff --git a/sdks/go/golem/wit/deps/golem-agent/common.wit b/sdks/go/golem/wit/deps/golem-agent/common.wit
new file mode 100644
index 0000000000..28b257612c
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-agent/common.wit
@@ -0,0 +1,237 @@
+package golem:agent@2.0.0;
+
+interface common {
+  use golem:core/types@2.0.0.{schema-graph, type-node-index, typed-schema-value,
+    metadata-envelope, agent-id, account-id, component-id};
+  use wasi:clocks/types@0.3.0.{duration};
+
+  enum agent-mode {
+    durable,
+    ephemeral
+  }
+
+  /// Full agent type declaration.
+  ///
+  /// `schema` is the per-agent type-node pool. Constructor / method / config
+  /// schema roots below are `type-node-index` values into `schema`. The
+  /// `schema.root` field is a structurally-required placeholder and is not the
+  /// semantic root of the agent type.
+  record agent-type {
+    type-name:       string,
+    description:     string,
+    source-language: string,
+    schema:          schema-graph,
+    %constructor:    agent-constructor,
+    methods:         list<agent-method>,
+    dependencies:    list<agent-dependency>,
+    mode:            agent-mode,
+    http-mount:      option<http-mount-details>,
+    snapshotting:    snapshotting,
+    config:       list<agent-config-declaration>,
+  }
+
+  /// Associates an agent type with a component that implements it
+  record registered-agent-type {
+    agent-type: agent-type,
+    implemented-by: component-id
+  }
+
+  /// Dependent agent type. All schema roots inside it resolve against its own
+  /// `schema`, not against the parent agent-type's graph.
+  record agent-dependency {
+    type-name:    string,
+    description:  option<string>,
+    schema:       schema-graph,
+    %constructor: agent-constructor,
+    methods:      list<agent-method>,
+  }
+
+  /// Ordered, named input parameters with per-field source annotation.
+  variant input-schema {
+    parameters(list<named-field>),
+  }
+
+  record named-field {
+    name:     string,
+    source:   field-source,
+    /// Index into the owning agent-type / dependency `schema` graph.
+    schema:   type-node-index,
+    metadata: metadata-envelope,
+  }
+
+  variant field-source {
+    user-supplied,
+    auto-injected(auto-injected-kind),
+  }
+
+  enum auto-injected-kind {
+    principal,
+  }
+
+  /// Output is either unit (no value) or a single value of the given type.
+  variant output-schema {
+    unit,
+    /// Index into the owning agent-type / dependency `schema` graph.
+    single(type-node-index),
+  }
+
+  record agent-method {
+    name:          string,
+    description:   string,
+    http-endpoint: list<http-endpoint-details>,
+    prompt-hint:   option<string>,
+    input-schema:  input-schema,
+    output-schema: output-schema,
+    read-only:     option<read-only-config>,
+  }
+
+  record read-only-config {
+    cache-policy:    cache-policy,
+    uses-principal:  bool,
+  }
+
+  variant cache-policy {
+    no-cache,
+    until-write,
+    ttl(duration),
+  }
+
+  record http-mount-details {
+    path-prefix:    list<path-segment>,
+    auth-details:   option<auth-details>,
+    phantom-agent:  bool,
+    cors-options:   cors-options,
+    webhook-suffix: list<path-segment>,
+  }
+
+  record cors-options {
+    allowed-patterns: list<string>,
+  }
+
+  record http-endpoint-details {
+    http-method: http-method,
+    path-suffix:  list<path-segment>,
+    header-vars:  list<header-variable>,
+    query-vars:   list<query-variable>,
+    auth-details: option<auth-details>,
+    cors-options: cors-options,
+  }
+
+  variant http-method {
+    get,
+    head,
+    post,
+    put,
+    delete,
+    connect,
+    options,
+    trace,
+    patch,
+    custom(string),
+  }
+
+  variant path-segment {
+    literal(string),
+    system-variable(system-variable),
+    path-variable(path-variable),
+    // only allowed as the last segment
+    remaining-path-variable(path-variable)
+  }
+
+  enum system-variable {
+    agent-type,
+    agent-version
+  }
+
+  record path-variable {
+    variable-name: string,
+  }
+
+  record header-variable {
+    header-name: string,
+    variable-name: string,
+  }
+
+  record query-variable {
+    query-param-name: string,
+    variable-name: string,
+  }
+
+  record auth-details {
+    required: bool,
+  }
+
+  variant principal {
+    oidc(oidc-principal),
+    agent(agent-principal),
+    golem-user(golem-user-principal),
+    anonymous
+  }
+
+  record oidc-principal {
+    sub:      string,
+    issuer: string,
+
+    email:    option<string>,
+    name:     option<string>,
+    email-verified: option<bool>,
+    given-name:     option<string>,
+    family-name:    option<string>,
+    picture:        option<string>,
+    preferred-username:       option<string>,
+
+    claims: string,
+  }
+
+  record agent-principal {
+    agent-id: agent-id,
+  }
+
+  record golem-user-principal {
+    account-id: account-id
+  }
+
+  record agent-constructor {
+    name:          option<string>,
+    description:   string,
+    prompt-hint:   option<string>,
+    input-schema:  input-schema,
+  }
+
+  variant snapshotting {
+    disabled,
+    enabled(snapshotting-config)
+  }
+
+  variant snapshotting-config {
+    default, // current default in the server
+    periodic(duration),
+    every-n-invocation(u16)
+  }
+
+  enum agent-config-source {
+    local,
+    secret
+  }
+
+  record agent-config-declaration {
+    source: agent-config-source,
+    path: list<string>,
+    /// Index into the owning agent-type `schema` graph.
+    value-type: type-node-index,
+  }
+
+  record typed-agent-config-value {
+    path: list<string>,
+    value: typed-schema-value,
+  }
+
+  /// Agent-level failures
+  variant agent-error {
+    invalid-input(string),
+    invalid-method(string),
+    invalid-type(string),
+    invalid-agent-id(string),
+    custom-error(typed-schema-value),
+  }
+}
diff --git a/sdks/go/golem/wit/deps/golem-agent/guest.wit b/sdks/go/golem/wit/deps/golem-agent/guest.wit
new file mode 100644
index 0000000000..dbe97ff310
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-agent/guest.wit
@@ -0,0 +1,37 @@
+package golem:agent@2.0.0;
+
+interface guest {
+  use golem:core/types@2.0.0.{schema-value-tree};
+  use common.{agent-error, agent-type, principal};
+
+  /// Initializes the agent of a given type with the given constructor parameters.
+  /// If called a second time, it fails.
+  ///
+  /// `input` is a value tree whose root encodes the constructor's parameter
+  /// list (one record field per declared `named-field`, in declaration order).
+  /// The guest interprets it against its own constructor `input-schema`.
+  initialize: async func(agent-type: string, input: schema-value-tree, principal: principal) -> result<_, agent-error>;
+
+  /// Invokes an agent. If create was not called before, it fails.
+  ///
+  /// `input` is a value tree whose root encodes the method's parameter list.
+  /// The result is `none` when the method's `output-schema` is `unit`, and
+  /// `some(value)` for a `single` output.
+  invoke: async func(method-name: string, input: schema-value-tree, principal: principal) -> result<option<schema-value-tree>, agent-error>;
+
+  /// Gets the agent type. If create was not called before, it fails
+  get-definition: func() -> agent-type;
+
+  /// Gets the agent types defined by this component
+  discover-agent-types: func() -> result<list<agent-type>, agent-error>;
+}
+
+world agent-guest {
+  import golem:api/host@1.5.0;
+  import common;
+  export guest;
+}
+
+world agent-host {
+  export host;
+}
diff --git a/sdks/go/golem/wit/deps/golem-agent/host.wit b/sdks/go/golem/wit/deps/golem-agent/host.wit
new file mode 100644
index 0000000000..345fa12b02
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-agent/host.wit
@@ -0,0 +1,143 @@
+package golem:agent@2.0.0;
+
+interface host {
+    use golem:core/types@2.0.0.{component-id, uuid, promise-id, schema-graph, schema-value-tree, typed-schema-value};
+    use wasi:clocks/system-clock@0.3.0.{instant as datetime};
+    use common.{agent-error, agent-type, registered-agent-type, typed-agent-config-value};
+
+    /// Gets all the registered agent types
+    get-all-agent-types: func() -> list<registered-agent-type>;
+
+    /// Get a specific registered agent type by name
+    get-agent-type: func(agent-type-name: string) -> option<registered-agent-type>;
+
+    /// Constructs a string agent-id from the agent type and its constructor parameters
+    /// and an optional phantom ID.
+    ///
+    /// `input` is a value tree whose root encodes the constructor's parameter list.
+    make-agent-id: func(agent-type-name: string, input: schema-value-tree, phantom-id: option<uuid>) -> result<string, agent-error>;
+
+    /// Parses an agent-id (created by `make-agent-id`) into an agent type name and its constructor parameters
+    /// and an optional phantom ID.
+    ///
+    /// The constructor parameters are returned as a self-contained typed value
+    /// (graph + value tree) so the receiver can interpret them without an
+    /// external schema registry.
+    parse-agent-id: func(agent-id: string) -> result<tuple<string, typed-schema-value, option<uuid>>, agent-error>;
+
+    /// Creates a webhook that can be used to integrate with webhook driven apis.
+    /// When the created url is called with a post request, the provided promise-id is completed with the body of the post request.
+    /// Note the following behaviours:
+    /// * Only agents whoose agent types are _currently_ deployed via an http api are allowed to create a webhook. Calling this function while the agent
+    ///    is not deployed via an http api will trap.
+    /// * Only the agent type that created the promise is allowed to create a webhook for it. Using this host function
+    ///   from a different agent type will trap.
+    create-webhook: func(promise-id: promise-id) -> string;
+
+    /// Possible failures of an RPC call
+    variant rpc-error {
+      /// Protocol level error
+      protocol-error(string),
+      /// Access denied
+      denied(string),
+      /// Target agent or function not found
+      not-found(string),
+      /// Internal error on the remote side
+      remote-internal-error(string),
+      /// The remote endpoint returned an agent-domain error
+      remote-agent-error(agent-error)
+    }
+
+    /// Final identity allocated for one remote invocation. For an ephemeral
+    /// target, `agent-id` contains the generated one-shot phantom ID.
+    record invocation-metadata {
+      agent-id: string,
+      idempotency-key: string,
+    }
+
+    /// Result of an awaited invocation together with its final identity.
+    record invocation-result-with-metadata {
+      metadata: invocation-metadata,
+      %result: option<schema-value-tree>,
+    }
+
+    /// Asynchronous invocation handle together with its final identity.
+    record async-invocation-with-metadata {
+      metadata: invocation-metadata,
+      %future: future-invoke-result,
+    }
+
+    /// Receipt returned when an invocation has been scheduled.
+    record scheduled-invocation-receipt {
+      metadata: invocation-metadata,
+    }
+
+    /// Receipt for a scheduled invocation that can still be cancelled.
+    record cancelable-scheduled-invocation-receipt {
+      metadata: invocation-metadata,
+      cancellation-token: cancellation-token,
+    }
+
+    /// An RPC client for invoking remote agents
+    resource wasm-rpc {
+      /// Constructs the RPC client connecting to the given target agent.
+      ///
+      /// `constructor` is a value tree whose root encodes the target agent
+      /// constructor's parameter list.
+      constructor(agent-type-name: string, %constructor: schema-value-tree, phantom-id: option<uuid>, agent-config: list<typed-agent-config-value>);
+
+      /// Invokes a remote method with the given parameters, and awaits the result.
+      ///
+      /// `input` encodes the method's parameter list. The returned result is
+      /// `none` for a `unit` output and `some(value)` for a `single` output.
+      invoke-and-await: func(method-name: string, input: schema-value-tree) -> result<invocation-result-with-metadata, rpc-error>;
+
+      /// Triggers the invocation of a remote method with the given parameters,
+      /// and returns its final identity immediately.
+      invoke: func(method-name: string, input: schema-value-tree) -> result<invocation-metadata, rpc-error>;
+
+      /// Invokes a remote method with the given parameters, and returns a `future-invoke-result` value which can
+      /// be polled for the result together with the final invocation identity.
+      ///
+      /// With this function it is possible to call multiple (different) agents simultaneously.
+      async-invoke-and-await: func(method-name: string, input: schema-value-tree) -> async-invocation-with-metadata;
+
+      /// Schedules an invocation for later and returns its final identity.
+      schedule-invocation: func(scheduled-time: datetime, method-name: string, input: schema-value-tree) -> scheduled-invocation-receipt;
+
+      /// Schedules an invocation for later and returns its final identity and
+      /// cancellation capability. Call cancel on the returned resource to
+      /// cancel the invocation before the scheduled time.
+      schedule-cancelable-invocation: func(scheduled-time: datetime, method-name: string, input: schema-value-tree) -> cancelable-scheduled-invocation-receipt;
+    }
+
+    /// Represents an asynchronous invocation result
+    resource future-invoke-result {
+      /// Awaits the result of the invocation.
+      get: async func() -> result<option<schema-value-tree>, rpc-error>;
+      /// Best-effort attempt to cancel the remote invocation by idempotency key.
+      /// If the invocation has already started or completed, this is a no-op.
+      cancel: func();
+    }
+
+    /// Cancellation token for scheduled invocations
+    resource cancellation-token {
+      /// Cancel the scheduled invocation
+      cancel: func();
+    }
+
+    /// Get the current value of the config key.
+    ///
+    /// The expected schema is a hint to the host what type of value is expected by the guest and can be used
+    /// by the host to automatically migrate config values to fit the expected schema.
+    ///
+    /// Only keys that are declared by the agent-type are allowed to be accessed. Trying
+    /// to access an undeclared key will trap, unless the expected type is an option. In that case
+    /// none is returned.
+    ///
+    /// Getting a local key will get values defined as part of the current
+    /// component revision + overrides declared during agent creation.
+    ///
+    /// Getting a shared key will get the current value of the key in the environment.
+    get-config-value: func(key: list<string>, expected: schema-graph) -> schema-value-tree;
+}
diff --git a/sdks/go/golem/wit/deps/golem-core-v2/golem-core-v2.wit b/sdks/go/golem/wit/deps/golem-core-v2/golem-core-v2.wit
new file mode 100644
index 0000000000..bb7dda191e
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-core-v2/golem-core-v2.wit
@@ -0,0 +1,587 @@
+// Language-independent value and type model used by Golem agents and the
+// platform's typed I/O surfaces.
+//
+// Recursive schema types and values are represented flat-with-indices because
+// WIT does not support recursive types. The matching in-memory forms in each
+// SDK (e.g., a recursive `SchemaType` / `SchemaValue` / `SchemaGraph` in Rust)
+// convert to and from this flat form mechanically.
+//
+// Design notes:
+//   - Graph-with-root: a `schema-graph` owns a `defs` list of named type
+//     definitions, a flat `type-nodes` list, and a root index.
+//     `schema-type-node::ref-type` references entries in `defs` by index. A
+//     `schema-graph` is always self-contained — there is no implicit external
+//     registry that consumers must look up.
+//   - `quantity-value` is a fixed-point decimal `mantissa * 10^(-scale)` with
+//     a unit string; mantissa fits in `s64` and scale fits in `s32`.
+
+package golem:core@2.0.0;
+
+interface types {
+    // ============================================================
+    // Carrier indices
+    // ============================================================
+
+    /// Index into a `schema-graph`'s `type-nodes` list.
+    type type-node-index = s32;
+
+    /// Index into a `schema-value-tree`'s `value-nodes` list.
+    type value-node-index = s32;
+
+    /// Index into a `schema-graph`'s `defs` list.
+    type def-index = s32;
+
+    /// Stable, language-independent identifier for a named type definition.
+    /// Must be unique within the enclosing `schema-graph`. Conventional format
+    /// is a dot-separated namespace path (e.g., `"myapp.users.user"`). Each
+    /// SDK provides a default derivation rule (typically based on the local
+    /// language's type name); cross-language interop requires the same
+    /// `type-id` on every side, which users can pin via the SDK's `named`
+    /// attribute.
+    type type-id = string;
+
+    // ============================================================
+    // Common embedded value types
+    // ============================================================
+
+    record uuid {
+        high-bits: u64,
+        low-bits: u64,
+    }
+
+    /// Parses a UUID from a string
+    parse-uuid: func(uuid: string) -> result<uuid, string>;
+
+    /// Converts a UUID to a string
+    uuid-to-string: func(uuid: uuid) -> string;
+
+    record datetime {
+        /// Seconds since the Unix epoch (UTC).
+        seconds: s64,
+        /// Nanoseconds since `seconds`, in `[0, 1_000_000_000)`.
+        nanoseconds: u32,
+    }
+
+    record environment-id {
+        uuid: uuid,
+    }
+
+    // ============================================================
+    // Platform identifiers
+    // ============================================================
+    //
+    // Platform identifiers used by the schema-native surfaces. Keeping them
+    // here lets migrated interfaces depend on a single core version.
+
+    /// Represents a Golem component
+    record component-id {
+        uuid: uuid,
+    }
+
+    /// Represents a Golem agent
+    record agent-id {
+        /// Identifies the component the agent belongs to
+        component-id: component-id,
+        /// String representation of the agent ID (agent type and constructor parameters)
+        agent-id: string,
+    }
+
+    /// Represents a Golem account
+    record account-id {
+        uuid: uuid,
+    }
+
+    /// Represents a Golem permission card
+    record card-id {
+        uuid: uuid
+    }
+
+    /// An index into the persistent log storing all performed operations of an agent
+    type oplog-index = u64;
+
+    /// A promise ID is a value that can be passed to an external Golem API to
+    /// complete that promise from an arbitrary external source, while Golem
+    /// agents can await for this completion.
+    record promise-id {
+        agent-id: agent-id,
+        oplog-idx: oplog-index,
+    }
+
+    // ============================================================
+    // Capability resources
+    // ============================================================
+
+    /// An unforgeable capability granting the right to consume a named
+    /// resource. The handle is opaque: a guest can only obtain one from the
+    /// host (e.g. via `golem:quota`) and can never inspect or fabricate its
+    /// internal state. When carried in a `schema-value-tree` (see
+    /// `schema-value-node::quota-token-handle`) the handle is transferred by
+    /// ownership; the host converts it to/from its internal trusted
+    /// representation at the boundary.
+    resource quota-token;
+
+    /// An unforgeable handle to sensitive material held by the runtime. The
+    /// handle is opaque to guests: components can pass it through schema values
+    /// and reveal it only through capability-gated host interfaces.
+    resource secret;
+
+    // ============================================================
+    // Schema graph (self-contained type carrier)
+    // ============================================================
+
+    /// A self-contained schema graph. Anywhere a schema travels with a value
+    /// (typed pair, oplog `custom` payload, REST/RPC envelope, public oplog
+    /// rendering), the payload owns its own `schema-graph` — there is no
+    /// implicit external registry that consumers must look up.
+    record schema-graph {
+        /// All schema-type nodes used in this graph. Reachable from `root`
+        /// directly (anonymous types) or transitively via `defs`.
+        type-nodes: list<schema-type-node>,
+        /// Named type definitions in this graph. Indices into this list are
+        /// the targets of `schema-type-node::ref-type`. Ordering is
+        /// deterministic (sorted by `id`).
+        defs: list<schema-type-def>,
+        /// Index into `type-nodes` of the root schema type.
+        root: type-node-index,
+    }
+
+    /// A named type definition inside a `schema-graph`.
+    ///
+    /// The def itself does not carry metadata; metadata lives on the
+    /// referenced `schema-type-node` so there is one source of truth for
+    /// docs / aliases / examples / deprecation / role on each type.
+    record schema-type-def {
+        /// Stable identifier; unique within the enclosing graph.
+        id: type-id,
+        /// Optional human-readable qualified name (display only).
+        name: option<string>,
+        /// Index into the enclosing graph's `type-nodes` for this def's body.
+        body: type-node-index,
+    }
+
+    /// Typed metadata envelope. Holds non-validation, non-rendering-critical
+    /// information (docs, aliases, examples, deprecation, role). Per-scalar
+    /// validation constraints live on the relevant scalar's typed substructure,
+    /// not here.
+    record metadata-envelope {
+        doc: option<string>,
+        aliases: list<string>,
+        /// Canonical-encoded example values (JSON strings). Empty = no examples.
+        /// Kept as strings so metadata is self-contained on the type side and
+        /// does not have to cross-reference an accompanying value tree.
+        examples: list<string>,
+        /// Deprecation message; `none` means not deprecated.
+        deprecated: option<string>,
+        /// Optional role annotation tagging a type with a consumer-facing intent.
+        role: option<role>,
+    }
+
+    /// Open registry; unknown roles fall back to structural handling.
+    variant role {
+        /// `list<variant<…>>` whose elements are interchangeable modalities.
+        multimodal,
+        /// `variant { inline: text, url: url }` ergonomic unstructured-text wrapper.
+        unstructured-text,
+        /// `variant { inline: binary, url: url }` ergonomic unstructured-binary wrapper.
+        unstructured-binary,
+        /// Any other producer-defined role, preserved verbatim.
+        other(string),
+    }
+
+    // ============================================================
+    // Schema type
+    // ============================================================
+
+    /// One node in a `schema-graph`. Carries the type body and a per-node
+    /// metadata envelope (docs, aliases, examples, deprecation, role).
+    /// Recursive positions reference other nodes (or named definitions) by
+    /// index inside the body.
+    record schema-type-node {
+        body: schema-type-body,
+        metadata: metadata-envelope,
+    }
+
+    /// The structural body of a `schema-type-node`.
+    ///
+    /// Closed sum types come in two shapes that differ by how the decoder
+    /// learns which branch a value belongs to:
+    ///
+    ///   - `variant-type` is a **carried-tag** sum: the value explicitly
+    ///     carries its case (`variant-value.case` index). Zero-inference
+    ///     decoding. Natural mapping for language-level algebraic data types
+    ///     (Rust `enum`, Scala `sealed trait`, WIT `variant`, etc.).
+    ///
+    ///   - `union-type` is an **inferred-tag** sum: the value does not carry
+    ///     its tag. Each branch declares a `discriminator-rule` (prefix /
+    ///     suffix / contains / regex on string-shaped bodies, or
+    ///     field-equals / field-absent on record-shaped bodies) and the
+    ///     decoder picks the branch whose rule matches the raw value.
+    ///     Natural mapping for inputs where the producer writes an unadorned
+    ///     value (a URL whose scheme picks the handler, a JSON object whose
+    ///     `"kind"` field picks the variant, an MCP content block whose
+    ///     `"type"` field picks the part shape, …).
+    variant schema-type-body {
+        // --- Reference to a named definition in the same `schema-graph` ---
+        ref-type(def-index),
+
+        // --- Primitives ---
+        bool-type,
+        s8-type(option<numeric-restrictions>),
+        s16-type(option<numeric-restrictions>),
+        s32-type(option<numeric-restrictions>),
+        s64-type(option<numeric-restrictions>),
+        u8-type(option<numeric-restrictions>),
+        u16-type(option<numeric-restrictions>),
+        u32-type(option<numeric-restrictions>),
+        u64-type(option<numeric-restrictions>),
+        f32-type(option<numeric-restrictions>),
+        f64-type(option<numeric-restrictions>),
+        char-type,
+        string-type,
+
+        // --- Structural composites ---
+        record-type(list<named-field-type>),
+        variant-type(list<variant-case-type>),
+        enum-type(list<string>),
+        flags-type(list<string>),
+        tuple-type(list<type-node-index>),
+        list-type(type-node-index),
+        fixed-list-type(fixed-list-spec),
+        map-type(map-spec),
+        option-type(type-node-index),
+        result-type(result-spec),
+
+        // --- Rich semantic types ---
+        text-type(text-restrictions),
+        binary-type(binary-restrictions),
+        path-type(path-spec),
+        url-type(url-restrictions),
+        datetime-type,
+        duration-type,
+        quantity-type(quantity-spec),
+
+        // --- Discriminated union (closed, inferred-tag) ---
+        union-type(union-spec),
+
+        // --- Capability nodes ---
+        secret-type(secret-spec),
+        quota-token-type(quota-token-spec),
+
+        // --- WASI P3 stubs (parseable only; no semantics yet) ---
+        future-type(option<type-node-index>),
+        stream-type(option<type-node-index>),
+    }
+
+    record named-field-type {
+        name: string,
+        body: type-node-index,
+        metadata: metadata-envelope,
+    }
+
+    record variant-case-type {
+        name: string,
+        payload: option<type-node-index>,
+        metadata: metadata-envelope,
+    }
+
+    record fixed-list-spec {
+        element: type-node-index,
+        length: u32,
+    }
+
+    /// Map key types are restricted to primitives. Enforced at schema
+    /// construction time, not by the WIT type itself.
+    record map-spec {
+        key: type-node-index,
+        value: type-node-index,
+    }
+
+    record result-spec {
+        ok: option<type-node-index>,
+        err: option<type-node-index>,
+    }
+
+    // --- Numeric restrictions ---
+
+    /// A numeric bound usable across every numeric representation. Float bounds
+    /// carry canonical IEEE-754 `f64` bits (NaN/inf rejected, -0.0 normalized);
+    /// comparisons decode the bits to `f64` and compare numerically.
+    variant numeric-bound {
+        signed(s64),
+        unsigned(u64),
+        float-bits(u64),
+    }
+
+    /// Inline numeric refinement. `none` on a numeric type means unconstrained
+    /// (the common case). The empty restriction set is never encoded as `some`:
+    /// producers normalize it to `none`, decoders normalize a decoded empty to
+    /// `none`. `unit` is schema/help metadata only.
+    record numeric-restrictions {
+        min:  option<numeric-bound>,
+        max:  option<numeric-bound>,
+        unit: option<string>,
+    }
+
+    // --- Text / Binary restrictions ---
+
+    record text-restrictions {
+        /// Optional set of allowed BCP-47 language codes. `none` = unrestricted.
+        languages: option<list<string>>,
+        min-length: option<u32>,
+        max-length: option<u32>,
+        regex: option<string>,
+    }
+
+    record binary-restrictions {
+        /// Optional set of allowed MIME types. `none` = unrestricted.
+        mime-types: option<list<string>>,
+        min-bytes: option<u32>,
+        max-bytes: option<u32>,
+    }
+
+    // --- Path ---
+
+    enum path-direction {
+        input,
+        output,
+        in-out,
+    }
+
+    enum path-kind {
+        file,
+        directory,
+        any,
+    }
+
+    record path-spec {
+        direction: path-direction,
+        kind: path-kind,
+        allowed-mime-types: option<list<string>>,
+        allowed-extensions: option<list<string>>,
+    }
+
+    // --- URL ---
+
+    record url-restrictions {
+        allowed-schemes: option<list<string>>,
+        allowed-hosts: option<list<string>>,
+    }
+
+    // --- Quantity ---
+
+    /// Fixed-point decimal value with unit: numeric value = `mantissa * 10^(-scale)`.
+    /// `unit` is a free-form string at the value level; the schema's
+    /// `quantity-spec` constrains the accepted set.
+    record quantity-value {
+        mantissa: s64,
+        scale: s32,
+        unit: string,
+    }
+
+    record quantity-spec {
+        /// Canonical base unit (e.g., `"kg"`, `"m"`, `"s"`, `"B"`).
+        base-unit: string,
+        /// Suffixes accepted on input and rendered on output (e.g., `["kg","g","mg"]`).
+        allowed-suffixes: list<string>,
+        /// Optional inclusive range, expressed in canonical fixed-point form.
+        min: option<quantity-value>,
+        max: option<quantity-value>,
+    }
+
+    // --- Discriminated union ---
+    //
+    // Inferred-tag sum. Each branch declares a rule that the decoder uses to
+    // identify values belonging to that branch from the raw underlying value.
+    //
+    // Rules enforced at schema-construction time:
+    //   - branch `tag`s are unique within the union,
+    //   - string-pattern discriminators (`prefix` / `suffix` / `contains` /
+    //     `regex`) require a string-shaped branch body (`string-type`,
+    //     `text-type`, `url-type`, `path-type`, or a `ref` resolving to one),
+    //   - record-shaped discriminators (`field-equals` / `field-absent`)
+    //     require a record-shaped branch body that declares the referenced
+    //     field (with the matching literal type, if any),
+    //   - the discriminator set must be unambiguous: no value matches more
+    //     than one branch. Overlap is checked structurally where decidable
+    //     (e.g., `prefix("a")` and `prefix("ab")` overlap) and best-effort
+    //     for `regex`.
+
+    record union-spec {
+        branches: list<union-branch>,
+    }
+
+    record union-branch {
+        /// Logical branch name. Carried in `union-value.tag` after the
+        /// decoder resolves the branch; used by renderers, codegen, docs.
+        tag: string,
+        /// Branch body type. Any schema type compatible with the
+        /// discriminator rule (see schema-construction validation above).
+        body: type-node-index,
+        /// Rule the decoder uses to pick this branch from a raw value.
+        discriminator: discriminator-rule,
+        metadata: metadata-envelope,
+    }
+
+    /// How the decoder identifies that a value belongs to a given union branch.
+    variant discriminator-rule {
+        /// String value starts with this prefix (e.g. `"ssh://"`).
+        prefix(string),
+        /// String value ends with this suffix (e.g. `".tar.gz"`).
+        suffix(string),
+        /// String value contains this substring.
+        contains(string),
+        /// String value matches this anchored regex.
+        regex(string),
+        /// Record-shaped value where the named field is present, and — if
+        /// `literal` is set — has the given literal string value. The common
+        /// JSON-discriminated-object case (`{"kind":"circle",…}`) is
+        /// `field-equals { field-name: "kind", literal: some("circle") }`.
+        field-equals(field-discriminator),
+        /// Record-shaped value where the named field is absent.
+        field-absent(string),
+    }
+
+    record field-discriminator {
+        field-name: string,
+        /// Optional required literal value for the field.
+        literal: option<string>,
+    }
+
+    // --- Capability nodes ---
+
+    record secret-spec {
+        /// Revealed payload type carried by this secret handle.
+        inner: type-node-index,
+        /// Optional categorisation (e.g., `"api-key"`, `"oauth-token"`).
+        category: option<string>,
+    }
+
+    record quota-token-spec {
+        /// Resource name this token covers (e.g., declared in the agent manifest).
+        /// `none` = any resource permitted.
+        resource-name: option<string>,
+    }
+
+    // ============================================================
+    // Schema value (always paired with a schema-graph)
+    // ============================================================
+
+    /// A flat schema-value tree. Always travels paired with a `schema-graph`
+    /// (see `typed-schema-value`). Indices refer to entries in `value-nodes`
+    /// within this same tree.
+    ///
+    /// The value tree is structurally driven by the schema: record-value
+    /// payload order matches the schema's field order, variant-value carries a
+    /// case index, enum-value carries a case index, union-value carries the
+    /// discriminator's literal tag. The value side does not redundantly carry
+    /// field names, case names, or named-ref identifiers — those come from the
+    /// schema.
+    record schema-value-tree {
+        value-nodes: list<schema-value-node>,
+        root: value-node-index,
+    }
+
+    variant schema-value-node {
+        // Primitives
+        bool-value(bool),
+        s8-value(s8),
+        s16-value(s16),
+        s32-value(s32),
+        s64-value(s64),
+        u8-value(u8),
+        u16-value(u16),
+        u32-value(u32),
+        u64-value(u64),
+        f32-value(f32),
+        f64-value(f64),
+        char-value(char),
+        string-value(string),
+
+        // Structural composites
+        record-value(list<value-node-index>),
+        variant-value(variant-value-payload),
+        enum-value(u32),
+        flags-value(list<bool>),
+        tuple-value(list<value-node-index>),
+        list-value(list<value-node-index>),
+        fixed-list-value(list<value-node-index>),
+        map-value(list<map-entry>),
+        option-value(option<value-node-index>),
+        result-value(result-value-payload),
+
+        // Rich semantic
+        text-value(text-value-payload),
+        binary-value(binary-value-payload),
+        path-value(string),
+        url-value(string),
+        datetime-value(datetime),
+        duration-value(duration-value-payload),
+        quantity-value-node(quantity-value),
+
+        // Discriminated union: tag is matched against schema branches.
+        union-value(union-value-payload),
+
+        // Capability nodes
+        secret-value(own<secret>),
+        quota-token-handle(own<quota-token>),
+
+        // WASI P3 stubs (parseable only in the schema; no constructible values).
+    }
+
+    record variant-value-payload {
+        case: u32,
+        payload: option<value-node-index>,
+    }
+
+    record map-entry {
+        key: value-node-index,
+        value: value-node-index,
+    }
+
+    /// Result payload: exactly one of `ok-value` / `err-value` is set. Each
+    /// inner option allows `result<_, _>` cases whose ok/err type is unit (no
+    /// payload).
+    variant result-value-payload {
+        ok-value(option<value-node-index>),
+        err-value(option<value-node-index>),
+    }
+
+    record text-value-payload {
+        text: string,
+        /// BCP-47 language tag, when known.
+        language: option<string>,
+    }
+
+    record binary-value-payload {
+        bytes: list<u8>,
+        mime-type: option<string>,
+    }
+
+    /// Signed duration as total nanoseconds.
+    record duration-value-payload {
+        nanoseconds: s64,
+    }
+
+    record union-value-payload {
+        /// Tag of the branch the decoder resolved, matching one of the
+        /// `union-spec::branches[*].tag` values. Carried so receivers do not
+        /// have to re-run discriminator rules to know which branch was
+        /// matched; encoders must ensure it agrees with the body.
+        tag: string,
+        /// Underlying value. Its shape matches the resolved branch's body
+        /// type and (by construction) satisfies the branch's discriminator
+        /// rule.
+        body: value-node-index,
+    }
+
+    // ============================================================
+    // Wire carriers
+    // ============================================================
+
+    /// A typed value: a self-contained schema graph paired with a value tree
+    /// built against that schema.
+    record typed-schema-value {
+        graph: schema-graph,
+        value: schema-value-tree,
+    }
+}
diff --git a/sdks/go/golem/wit/deps/golem-durability/golem-durability.wit b/sdks/go/golem/wit/deps/golem-durability/golem-durability.wit
new file mode 100644
index 0000000000..c23c70ceae
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-durability/golem-durability.wit
@@ -0,0 +1,85 @@
+package golem:durability@1.5.0;
+
+interface durability {
+    use golem:api/host@1.5.0.{persistence-level};
+    use golem:api/oplog@1.5.0.{oplog-index, wrapped-function-type};
+    use wasi:clocks/system-clock@0.3.0.{instant as datetime};
+    use golem:core/types@2.0.0.{typed-schema-value};
+
+    type durable-function-type = wrapped-function-type;
+
+    /// Represents the current durable execution state
+    record durable-execution-state {
+        /// If true, the executor is in live mode, side-effects should be performed and persisted.
+        /// If false, the executor is in replay mode, side-effects should be replayed from the persisted data.
+        is-live: bool,
+        /// The currently active persistence level
+        persistence-level: persistence-level,
+    }
+
+    /// Represents the oplog entry version; this is for backward compatibility and most use cases should always use
+    /// (and expect) the latest version.
+    enum oplog-entry-version {
+        v1,
+        v2
+    }
+
+    /// Represents a persisted durable function invocation. The `response` field
+    /// contains a value and its schema graph together, making the user-defined payload observable by external tools.
+    record persisted-durable-function-invocation {
+        /// The timestamp of the invocation.
+        timestamp: datetime,
+        /// The invoked function's unique name
+        function-name: string,
+        /// Arbitrary structured value and schema graph describing the invocation's result
+        response: typed-schema-value,
+        /// Type of the durable function invocation
+        function-type: durable-function-type,
+        /// Oplog entry version
+        entry-version: oplog-entry-version
+    }
+
+    /// Observes a function call (produces logs and metrics)
+    observe-function-call: func(iface: string, function: string);
+
+    /// Marks the beginning of a durable function.
+    ///
+    /// There must be a corresponding call to `end-durable-function` after the function has
+    /// performed its work (it can be ended in a different context, for example after an async
+    /// pollable operation has been completed)
+    begin-durable-function: func(function-type: durable-function-type) -> oplog-index;
+
+    /// Marks the end of a durable function
+    ///
+    /// This is a pair of `begin-durable-function` and should be called after the durable function
+    /// has performed and persisted or replayed its work. The `begin-index` should be the index
+    /// returned by `begin-durable-function`.
+    ///
+    /// Normally commit behavior is decided by the executor based on the `function-type`. However, in special
+    /// cases the `forced-commit` parameter can be used to force commit the oplog in an efficient way.
+    end-durable-function: func(function-type: durable-function-type, begin-index: oplog-index, forced-commit: bool);
+
+    /// Gets the current durable execution state
+    current-durable-execution-state: func() -> durable-execution-state;
+
+    /// Writes a record to the agent's oplog representing a durable function invocation
+    ///
+    /// The request and response are defined as schema-carrying values, which makes it
+    /// self-describing for observers of oplogs.
+    persist-durable-function-invocation: func(
+        function-name: string,
+        request: typed-schema-value,
+        response: typed-schema-value,
+        function-type: durable-function-type,
+    );
+
+    /// Reads the next persisted durable function invocation from the oplog during replay
+    read-persisted-durable-function-invocation: func() -> persisted-durable-function-invocation;
+
+    // The p2 version of this interface had a `lazy-initialized-pollable` resource: a
+    // host-owned pollable that was ready while unattached (during replay) and could later
+    // be re-bound to a real pollable when execution went live. It has no p3 equivalent
+    // and none is needed: p3 `future`/`stream` handles are one-shot and guest-creatable,
+    // so durable stream wrappers express the replay-to-live transition by resolving
+    // replayed results immediately and directly awaiting the live source afterwards.
+}
diff --git a/sdks/go/golem/wit/deps/golem-quota/types.wit b/sdks/go/golem/wit/deps/golem-quota/types.wit
new file mode 100644
index 0000000000..a6acaec556
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-quota/types.wit
@@ -0,0 +1,76 @@
+package golem:quota@1.5.0;
+
+/// Host interface for the Golem quota system.
+///
+/// Agents use quota-tokens to declare intent to consume a named resource and to
+/// reserve / commit actual usage.
+///
+/// The `quota-token` capability itself is defined in `golem:core/types` so that
+/// it can travel inside a `schema-value-tree` as an opaque, unforgeable handle.
+/// This interface only exposes the operations that act on such a handle.
+interface types {
+    use golem:core/types@2.0.0.{quota-token};
+
+    /// Error returned when a reservation cannot be satisfied because the
+    /// resource's enforcement policy is `reject`.
+    ///
+    /// The inner value is an optional estimate in nanoseconds of how long
+    /// the caller would need to wait for capacity (only available for
+    /// rate-limited resources).
+    record failed-reservation {
+        estimated-wait-nanos: option<u64>,
+    }
+
+    /// A short-lived capability that represents a pending or committed
+    /// resource consumption.  Drop without committing is equivalent to
+    /// committing zero usage.
+    resource reservation {
+        /// Commit actual usage, consuming the reservation.
+        ///
+        /// If `used` < reserved  — unused capacity is returned to the pool.
+        /// If `used` > reserved  — the excess is deducted from the token's
+        ///                          remaining allocation as "debt".
+        commit: static func(this: reservation, used: u64);
+    }
+
+    /// Request a quota capability for the given resource.
+    /// - `resource-name` : the resource name (as declared in the manifest).
+    /// - `expected-use`  : expected units per reservation; used to derive
+    ///                      credit rate and max-credit for fair scheduling.
+    new-token: func(
+        resource-name: string,
+        expected-use: u64,
+    ) -> quota-token;
+
+    /// Reserve `amount` units from the token's local allocation.
+    ///
+    /// Blocks internally until capacity is available or the resource's
+    /// enforcement action fires.  Returns a `reservation` handle that
+    /// must be committed (or dropped) to release unused capacity.
+    reserve: func(
+        token: borrow<quota-token>,
+        amount: u64,
+    ) -> result<reservation, failed-reservation>;
+
+    /// Split off a child token with `child-expected-use` units from `token`.
+    ///
+    /// The parent's `expected-use` is reduced by `child-expected-use`.
+    /// Credits are divided proportionally between parent and child.
+    ///
+    /// Traps if `child-expected-use` exceeds the parent's current `expected-use`.
+    split: func(
+        token: borrow<quota-token>,
+        child-expected-use: u64,
+    ) -> quota-token;
+
+    /// Merge `other` back into `token`.
+    ///
+    /// The two tokens must refer to the same resource (same resource-name
+    /// and environment).  `other` is consumed.
+    ///
+    /// Traps if the tokens refer to different resources.
+    merge: func(
+        token: borrow<quota-token>,
+        other: quota-token,
+    );
+}
diff --git a/sdks/go/golem/wit/deps/golem-rdbms/ignite.wit b/sdks/go/golem/wit/deps/golem-rdbms/ignite.wit
new file mode 100644
index 0000000000..505988023d
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-rdbms/ignite.wit
@@ -0,0 +1,81 @@
+// Copyright 2024-2025 Golem Cloud
+//
+// Licensed under the Golem Source License v1.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://license.golem.cloud/LICENSE
+//
+// 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 golem:rdbms@1.5.0;
+
+interface ignite2 {
+  // ── Error ──────────────────────────────────────────────────────────────────
+  variant error {
+    connection-failure(string),
+    query-parameter-failure(string),
+    query-execution-failure(string),
+    query-response-failure(string),
+    other(string),
+  }
+
+  // ── Value types (maps 1-to-1 onto ignite_client::IgniteValue) ─────────────
+  variant db-value {
+    db-null,
+    db-boolean(bool),
+    db-byte(s8),
+    db-short(s16),
+    db-int(s32),
+    db-long(s64),
+    db-float(f32),
+    db-double(f64),
+    /// 16-bit Unicode code unit (Java char).
+    db-char(u16),
+    db-string(string),
+    db-uuid(tuple<u64, u64>),
+    /// Milliseconds since Unix epoch (UTC).
+    db-date(s64),
+    /// (milliseconds since epoch, sub-millisecond nanoseconds 0..999_999).
+    db-timestamp(tuple<s64, s32>),
+    /// Nanoseconds since midnight.
+    db-time(s64),
+    db-decimal(string),
+    db-byte-array(list<u8>),
+  }
+
+  // ── Metadata ───────────────────────────────────────────────────────────────
+  record db-column { ordinal: u64, name: string }
+  record db-row    { values: list<db-value> }
+  record db-result { columns: list<db-column>, rows: list<db-row> }
+
+  // ── Resources ──────────────────────────────────────────────────────────────
+  resource db-result-stream {
+    get-columns: func() -> result<list<db-column>, error>;
+    get-next:    func() -> result<option<list<db-row>>, error>;
+  }
+
+  resource db-transaction {
+    query:        func(statement: string, params: list<db-value>) -> result<db-result, error>;
+    query-stream: func(statement: string, params: list<db-value>) -> result<db-result-stream, error>;
+    execute:      func(statement: string, params: list<db-value>) -> result<s64, error>;
+    commit:       func() -> result<_, error>;
+    rollback:     func() -> result<_, error>;
+  }
+
+  resource db-connection {
+    /// Open a connection to an Apache Ignite 2.x node.
+    ///
+    /// Address format: `ignite://[user:pass@]host:port[?pool_size=N&tls=true]`
+    /// Default port: 10800.
+    open:              static func(address: string) -> result<db-connection, error>;
+    query:             func(statement: string, params: list<db-value>) -> result<db-result, error>;
+    query-stream:      func(statement: string, params: list<db-value>) -> result<db-result-stream, error>;
+    execute:           func(statement: string, params: list<db-value>) -> result<s64, error>;
+    begin-transaction: func() -> result<db-transaction, error>;
+  }
+}
diff --git a/sdks/go/golem/wit/deps/golem-rdbms/mysql.wit b/sdks/go/golem/wit/deps/golem-rdbms/mysql.wit
new file mode 100644
index 0000000000..49247006d9
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-rdbms/mysql.wit
@@ -0,0 +1,138 @@
+package golem:rdbms@1.5.0;
+
+interface mysql {
+  use types.{date, time, timestamp};
+
+  variant error {
+    connection-failure(string),
+    query-parameter-failure(string),
+    query-execution-failure(string),
+    query-response-failure(string),
+    other(string)
+  }
+
+  variant db-column-type {
+     boolean,
+     tinyint,
+     smallint,
+     mediumint,
+     int,
+     bigint,
+     tinyint-unsigned,
+     smallint-unsigned,
+     mediumint-unsigned,
+     int-unsigned,
+     bigint-unsigned,
+     float,
+     double,
+     decimal,
+     date,
+     datetime,
+     timestamp,
+     time,
+     year,
+     fixchar,
+     varchar,
+     tinytext,
+     text,
+     mediumtext,
+     longtext,
+     binary,
+     varbinary,
+     tinyblob,
+     blob,
+     mediumblob,
+     longblob,
+     enumeration,
+     set,
+     bit,
+     json
+  }
+
+  record db-column {
+    ordinal:     u64,
+    name:        string,
+    db-type:     db-column-type,
+    db-type-name: string
+  }
+
+  /// Value descriptor for a single database value
+  variant db-value {
+       boolean(bool),
+       tinyint(s8),
+       smallint(s16),
+       mediumint(s32),
+       int(s32),
+       bigint(s64),
+       tinyint-unsigned(u8),
+       smallint-unsigned(u16),
+       mediumint-unsigned(u32),
+       int-unsigned(u32),
+       bigint-unsigned(u64),
+       float(f32),
+       double(f64),
+       decimal(string),
+       date(date),
+       datetime(timestamp),
+       timestamp(timestamp),
+       time(time),
+       year(u16),
+       fixchar(string),
+       varchar(string),
+       tinytext(string),
+       text(string),
+       mediumtext(string),
+       longtext(string),
+       binary(list<u8>),
+       varbinary(list<u8>),
+       tinyblob(list<u8>),
+       blob(list<u8>),
+       mediumblob(list<u8>),
+       longblob(list<u8>),
+       enumeration(string),
+       set(string),
+       bit(list<bool>),
+       json(string),
+       null
+  }
+
+  /// A single row of values
+  record db-row {
+    values: list<db-value>
+  }
+
+  record db-result {
+    columns: list<db-column>,
+    rows: list<db-row>
+  }
+
+  /// A potentially very large and lazy stream of rows:
+  resource db-result-stream {
+    get-columns: func() -> list<db-column>;
+    get-next: func() -> option<list<db-row>>;
+  }
+
+  resource db-connection {
+    open: static func(address: string) -> result<db-connection, error>;
+
+    query: func(statement: string, params: list<db-value>) -> result<db-result, error>;
+
+    query-stream: func(statement: string, params: list<db-value>) -> result<db-result-stream, error>;
+
+    execute: func(statement: string, params: list<db-value>) -> result<u64, error>;
+
+    begin-transaction: func() -> result<db-transaction, error>;
+  }
+
+  resource db-transaction {
+    query: func(statement: string, params: list<db-value>) -> result<db-result, error>;
+
+    query-stream: func(statement: string, params: list<db-value>) -> result<db-result-stream, error>;
+
+    execute: func(statement: string, params: list<db-value>) -> result<u64, error>;
+
+    commit: func() -> result<_, error>;
+
+    rollback: func() -> result<_, error>;
+  }
+}
diff --git a/sdks/go/golem/wit/deps/golem-rdbms/postgres.wit b/sdks/go/golem/wit/deps/golem-rdbms/postgres.wit
new file mode 100644
index 0000000000..b68b7ab148
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-rdbms/postgres.wit
@@ -0,0 +1,293 @@
+package golem:rdbms@1.5.0;
+
+interface postgres {
+  use types.{date, time, timetz, timestamp, timestamptz, uuid, ip-address, mac-address};
+
+  variant error {
+    connection-failure(string),
+    query-parameter-failure(string),
+    query-execution-failure(string),
+    query-response-failure(string),
+    other(string)
+  }
+
+  record interval {
+    months: s32,
+    days: s32,
+    microseconds: s64
+  }
+
+  variant int4bound {
+    included(s32),
+    excluded(s32),
+    unbounded
+  }
+
+  variant int8bound {
+    included(s64),
+    excluded(s64),
+    unbounded
+  }
+
+  variant numbound {
+    included(string),
+    excluded(string),
+    unbounded
+  }
+
+  variant tsbound {
+    included(timestamp),
+    excluded(timestamp),
+    unbounded
+  }
+
+  variant tstzbound {
+    included(timestamptz),
+    excluded(timestamptz),
+    unbounded
+  }
+
+  variant datebound {
+    included(date),
+    excluded(date),
+    unbounded
+  }
+
+  record int4range {
+    start: int4bound,
+    end: int4bound
+  }
+
+  record int8range {
+    start: int8bound,
+    end: int8bound
+  }
+
+  record numrange {
+    start: numbound,
+    end: numbound
+  }
+
+  record tsrange {
+    start: tsbound,
+    end: tsbound
+  }
+
+  record tstzrange {
+    start: tstzbound,
+    end: tstzbound
+  }
+
+  record daterange {
+    start: datebound,
+    end: datebound
+  }
+
+  record enumeration-type {
+    name: string
+  }
+
+  record enumeration {
+    name: string,
+    value: string
+  }
+
+  record composite-type {
+    name: string,
+    attributes: list<tuple<string, lazy-db-column-type>>
+  }
+
+  record composite {
+    name: string,
+    values: list<lazy-db-value>
+  }
+
+  record domain-type {
+    name: string,
+    base-type: lazy-db-column-type
+  }
+
+  record domain {
+    name: string,
+    value: lazy-db-value
+  }
+
+  record range-type {
+    name: string,
+    base-type: lazy-db-column-type
+  }
+
+  variant value-bound {
+    included(lazy-db-value),
+    excluded(lazy-db-value),
+    unbounded
+  }
+
+  record values-range {
+    start: value-bound,
+    end: value-bound
+  }
+
+  record range {
+    name: string,
+    value: values-range
+  }
+
+  record sparse-vec {
+    dim: s32,
+    indices: list<s32>,
+    values: list<f32>
+  }
+
+  variant db-column-type {
+    character,
+    int2,
+    int4,
+    int8,
+    float4,
+    float8,
+    numeric,
+    boolean,
+    text,
+    varchar,
+    bpchar,
+    timestamp,
+    timestamptz,
+    date,
+    time,
+    timetz,
+    interval,
+    bytea,
+    uuid,
+    xml,
+    json,
+    jsonb,
+    jsonpath,
+    inet,
+    cidr,
+    macaddr,
+    bit,
+    varbit,
+    int4range,
+    int8range,
+    numrange,
+    tsrange,
+    tstzrange,
+    daterange,
+    money,
+    oid,
+    enumeration(enumeration-type),
+    composite(composite-type),
+    domain(domain-type),
+    array(lazy-db-column-type),
+    range(range-type),
+    vector,
+    halfvec,
+    sparsevec
+  }
+
+  variant db-value {
+    character(s8),
+    int2(s16),
+    int4(s32),
+    int8(s64),
+    float4(f32),
+    float8(f64),
+    numeric(string),
+    boolean(bool),
+    text(string),
+    varchar(string),
+    bpchar(string),
+    timestamp(timestamp),
+    timestamptz(timestamptz),
+    date(date),
+    time(time),
+    timetz(timetz),
+    interval(interval),
+    bytea(list<u8>),
+    json(string),
+    jsonb(string),
+    jsonpath(string),
+    xml(string),
+    uuid(uuid),
+    inet(ip-address),
+    cidr(ip-address),
+    macaddr(mac-address),
+    bit(list<bool>),
+    varbit(list<bool>),
+    int4range(int4range),
+    int8range(int8range),
+    numrange(numrange),
+    tsrange(tsrange),
+    tstzrange(tstzrange),
+    daterange(daterange),
+    money(s64),
+    oid(u32),
+    enumeration(enumeration),
+    composite(composite),
+    domain(domain),
+    array(list<lazy-db-value>),
+    range(range),
+    null,
+    vector(list<f32>),
+    halfvec(list<f32>),
+    sparsevec(sparse-vec)
+  }
+
+  resource lazy-db-value {
+    constructor(value: db-value);
+    get: func() -> db-value;
+  }
+
+  resource lazy-db-column-type {
+    constructor(value: db-column-type);
+    get: func() -> db-column-type;
+  }
+
+  record db-column {
+    ordinal:     u64,
+    name:        string,
+    db-type:     db-column-type,
+    db-type-name: string
+  }
+
+  /// A single row of values
+  record db-row {
+    values: list<db-value>
+  }
+
+  record db-result {
+    columns: list<db-column>,
+    rows: list<db-row>
+  }
+
+  /// A potentially very large and lazy stream of rows:
+  resource db-result-stream {
+    get-columns: func() -> list<db-column>;
+    get-next: func() -> option<list<db-row>>;
+  }
+
+  resource db-connection {
+    open: static func(address: string) -> result<db-connection, error>;
+
+    query: func(statement: string, params: list<db-value>) -> result<db-result, error>;
+
+    query-stream: func(statement: string, params: list<db-value>) -> result<db-result-stream, error>;
+
+    execute: func(statement: string, params: list<db-value>) -> result<u64, error>;
+
+    begin-transaction: func() -> result<db-transaction, error>;
+  }
+
+  resource db-transaction {
+    query: func(statement: string, params: list<db-value>) -> result<db-result, error>;
+
+    query-stream: func(statement: string, params: list<db-value>) -> result<db-result-stream, error>;
+
+    execute: func(statement: string, params: list<db-value>) -> result<u64, error>;
+
+    commit: func() -> result<_, error>;
+
+    rollback: func() -> result<_, error>;
+  }
+}
diff --git a/sdks/go/golem/wit/deps/golem-rdbms/types.wit b/sdks/go/golem/wit/deps/golem-rdbms/types.wit
new file mode 100644
index 0000000000..36af8b1fde
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-rdbms/types.wit
@@ -0,0 +1,47 @@
+package golem:rdbms@1.5.0;
+
+interface types {
+
+  record uuid {
+    high-bits: u64,
+    low-bits: u64
+  }
+
+  variant ip-address {
+    ipv4(tuple<u8, u8, u8, u8>),
+    ipv6(tuple<u16, u16, u16, u16, u16, u16, u16, u16>),
+  }
+
+  record mac-address {
+    octets: tuple<u8, u8, u8, u8, u8, u8>
+  }
+
+  record date {
+    year: s32,
+    month: u8,
+    day: u8
+  }
+
+  record time {
+    hour: u8,
+    minute: u8,
+    second: u8,
+    nanosecond: u32
+  }
+
+  record timestamp {
+    date: date,
+    time: time
+  }
+
+  record timestamptz {
+    timestamp: timestamp,
+    offset: s32
+  }
+
+  record timetz {
+    time: time,
+    offset: s32
+  }
+
+}
diff --git a/sdks/go/golem/wit/deps/golem-rdbms/world.wit b/sdks/go/golem/wit/deps/golem-rdbms/world.wit
new file mode 100644
index 0000000000..f8702cbf16
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-rdbms/world.wit
@@ -0,0 +1,7 @@
+package golem:rdbms@1.5.0;
+
+world imports {
+     import postgres;
+     import mysql;
+     import ignite2;
+}
diff --git a/sdks/go/golem/wit/deps/golem-secrets/reveal.wit b/sdks/go/golem/wit/deps/golem-secrets/reveal.wit
new file mode 100644
index 0000000000..76a81735f6
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-secrets/reveal.wit
@@ -0,0 +1,31 @@
+package golem:secrets@0.1.0;
+
+/// Capability-gated escape hatch: convert a secret resource back
+/// to plaintext. The capability is the import — components that
+/// do not import this interface cannot reveal secrets. v1 grants
+/// reveal at the import-or-not level only; v2 introduces
+/// per-(agent, tool, tool-middleware) manifest binding axes that narrow
+/// reveal even when imported (§5.6).
+///
+/// Every successful reveal is recorded in the calling agent's
+/// oplog as `(calling-agent, secret-id, timestamp)`. The
+/// plaintext bytes are not part of the audit record.
+///
+/// Tools that consume secrets at the wire boundary (HTTP
+/// authorization headers, signing operations, encryption) SHOULD
+/// prefer host-mediated substitution over reveal — host
+/// capabilities accepting `borrow<secret>` directly let the
+/// runtime substitute plaintext at the syscall boundary, never
+/// crossing into guest linear memory at all. Reveal is the
+/// fallback for genuinely custom protocols the host doesn't
+/// natively support; its use is loud by design.
+interface reveal {
+  use types.{secret-error};
+  use golem:core/types@2.0.0.{secret, schema-graph, schema-value-tree};
+
+  /// Unpack a secret resource to its inner typed value. `expected` is the
+  /// guest's inner-type graph; the host validates it against the secret's
+  /// pinned inner type and returns the stored value as a schema-value-tree.
+  reveal: func(s: borrow<secret>, expected: schema-graph)
+    -> result<schema-value-tree, secret-error>;
+}
diff --git a/sdks/go/golem/wit/deps/golem-secrets/types.wit b/sdks/go/golem/wit/deps/golem-secrets/types.wit
new file mode 100644
index 0000000000..1e10ce9e10
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-secrets/types.wit
@@ -0,0 +1,73 @@
+package golem:secrets@0.1.0;
+
+/// The secret resource, plus the metadata records other interfaces
+/// reference. Components that only need to *receive and pass*
+/// secrets — most tools, audit middleware, MCP-import bridges —
+/// import only this interface.
+interface types {
+  use wasi:clocks/system-clock@0.3.0.{instant as datetime};
+  use golem:core/types@2.0.0.{secret};
+
+  /// The opaque handle to a sensitive value is defined in
+  /// `golem:core/types` so it can travel inside a `schema-value-tree` as an
+  /// unforgeable owned handle. This interface exposes only safe metadata
+  /// operations over that handle.
+  ///
+  /// Resource handles are scoped to a component instance's
+  /// resource table. When a secret is passed across a component
+  /// boundary (e.g., agent → tool via `tool-rpc.invoke`'s
+  /// `value-tree`), the runtime issues a fresh handle in the
+  /// receiving instance's table that points at the same
+  /// host-side state. The wire form carries only the
+  /// `secret-id`, never plaintext.
+
+  /// Stable, opaque identifier scoped to the deployment.
+  record secret-id {
+    bytes: list<u8>,
+  }
+
+  record secret-metadata {
+    /// Config-key path the secret resolved from, when applicable.
+    /// `none` for secrets returned in tool-result position.
+    config-key:  option<list<string>>,
+    /// Pinned version captured at resolve-time. `none` for
+    /// dynamic-origin secrets (e.g. returned from a tool that
+    /// didn't itself have a versioned source).
+    version:     option<secret-version>,
+    /// Time of resolution.
+    resolved-at: datetime,
+    /// The semantic category declared on the secret's schema type, when
+    /// known. Mirrors `secret-spec.category` in `golem:core/types`.
+    category:    option<string>,
+  }
+
+  /// A secret-store-assigned, monotonic version identifier. The
+  /// secret-store backend defines the ordering and the format;
+  /// the type-tree treats it as opaque.
+  record secret-version {
+    bytes: list<u8>,
+  }
+
+  /// Stable opaque identifier. Comparing equal across two `secret` handles
+  /// means "same secret material, same version" — useful for caching and audit
+  /// correlation. Safe to log, oplog, and emit in traces.
+  id: func(s: borrow<secret>) -> secret-id;
+
+  /// Immutable metadata captured at resolve-time. Includes the config-key
+  /// path, the resolved version, and the resolution timestamp. No plaintext.
+  metadata: func(s: borrow<secret>) -> secret-metadata;
+
+  /// Errors common to operations on secrets.
+  variant secret-error {
+    /// The secret was bound but its current resolution failed
+    /// (e.g., the secret-store entry was deleted between binding
+    /// and reveal, or the network to the store is partitioned).
+    unavailable(string),
+    /// The secret was version-pinned and the pinned version no
+    /// longer exists (administratively destroyed).
+    version-not-found(secret-version),
+    /// Internal runtime error (carries an opaque message; never
+    /// includes plaintext).
+    internal(string),
+  }
+}
diff --git a/sdks/go/golem/wit/deps/golem-tool/common.wit b/sdks/go/golem/wit/deps/golem-tool/common.wit
new file mode 100644
index 0000000000..7e3dba1d14
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-tool/common.wit
@@ -0,0 +1,379 @@
+package golem:tool@0.1.0;
+
+/// Data model for Golem tool metadata.
+///
+/// A "tool" is a callable unit declared from a single piece of
+/// metadata. From that metadata the SDKs project two delivered
+/// surfaces — typed function signatures in TypeScript / Rust /
+/// Python / Scala / MoonBit for programmatic invocation, and
+/// help-text rendering for any node in the command tree — and the
+/// same metadata is sufficient to drive a future full-CLI
+/// projection (parseable args, shell completions, exit codes,
+/// terminal-runnable as a Unix utility) without further authoring.
+/// The CLI projection is a future possibility enabled by the model;
+/// it is not part of the current specification's deliverable.
+///
+/// The model is CLI-native: commands, subcommands, options, flags, and
+/// positionals are primary — not a generic data schema with CLI mappings
+/// layered on top. Constraint-by-construction is preferred over runtime
+/// validation: variadic-only-at-tail is structural; mutual exclusion is
+/// expressed by subcommand choice or by an explicit `mutex-groups`
+/// constraint; co-occurrence is structural via sub-records or via
+/// `all-or-none`.
+///
+/// Types and values are not modeled by this package: every input/output
+/// type and every metadata-time or runtime value is expressed with the
+/// shared `golem:core/types@2.0.0` schema model. A tool owns a single
+/// `schema-graph` type-node pool (the `tool.schema` field); command bodies
+/// reference entries in it by `type-node-index`, exactly the same way the
+/// agent model (`golem:agent/common`) references its per-agent
+/// `schema-graph`. Metadata-time values (option/positional defaults, the
+/// literal side of `value-is` constraint refs) are `schema-value-tree`s
+/// interpreted against the referenced type node in `tool.schema`; runtime
+/// invocation inputs, results, and custom-error payloads are self-contained
+/// `typed-schema-value`s.
+///
+/// The remaining tool-specific recursion site is the command tree: a
+/// flattened command hierarchy with the root at index 0 and children
+/// referenced by `command-index`.
+///
+/// Construction invariants (validated by the producer; the WIT shape
+/// alone does not enforce them):
+///
+///   • All identifier-like strings (command names, option/flag long
+///     names, positional names, error names, formatter names) match
+///     `^[a-z][a-z0-9]*(-[a-z0-9]+)*$`.
+///   • Subcommand names + aliases are pairwise unique among siblings.
+///   • Within a `command-body`: option long-names + flag long-names +
+///     positional names + aliases + short forms are pairwise unique,
+///     AND unique against globals inherited from any ancestor command.
+///   • Constraint `ref` names resolve against body-declared options /
+///     flags / positionals AND globals inherited from any ancestor.
+///   • For `ref::value-is(name, lit)`, the literal must be a valid value
+///     for the declared type node of `name` in `tool.schema`.
+///   • `default-formatter` resolves to a name in `formatters`.
+///   • `tail-positional`: if `verbatim` is true, `separator` must be
+///     `some`; `separator` with `min = 0` is legal (the separator alone,
+///     no items, is valid).
+///   • A `positional` / `option` / `result` / `error` `type-node-index`
+///     resolves to a node in `tool.schema`.
+///   • A `repeatable-list` option's `default`, if present, is a `list`
+///     whose elements are values of the `repeatable-list-shape.item-type`
+///     node. A `repeatable-map` option's `default`, if present, is a `map`
+///     value of the `repeatable-map-shape.map-type` node.
+///   • A `value-is` ref naming a `repeatable-list` option, tail positional,
+///     or otherwise list-shaped target means "any occurrence / element
+///     equals this literal"; the literal is a value of the element type. For
+///     a `repeatable-map` option the literal is a value of the map's value
+///     type (any entry's value equals this literal).
+///   • The tool's identity is its root command name
+///     (`commands.nodes[0].name`); `get-tool(name)` and
+///     `guest.invoke(tool-name, …)` match against it. `commands.nodes`
+///     is always non-empty.
+///
+/// Capability scoping (WASI preopens, env masking, outbound-socket
+/// filters, subprocess-exec capability, and `golem:agent/host`'s
+/// `get-config-value` resolution) is performed by the host by inspecting
+/// the component's WIT imports — what a component *can* do is already
+/// declared structurally by which interfaces it imports — not by reading
+/// a declarative metadata record.
+interface common {
+  use golem:core/types@2.0.0.{schema-graph, type-node-index, schema-value-tree,
+    typed-schema-value};
+
+  // Top level
+  record tool {
+    version:  string,
+    commands: command-tree,
+    /// Self-contained type-node pool holding every type referenced from
+    /// this tool's commands. Command bodies reference entries by
+    /// `type-node-index`. `schema.root` is a structurally-required
+    /// placeholder and is not the semantic root of the tool (mirrors
+    /// `golem:agent/common`'s `agent-type.schema`).
+    schema:   schema-graph,
+  }
+
+  // Command tree
+  type command-index = s32;
+
+  record command-tree {
+    /// Always non-empty; the root command is at index 0.
+    nodes: list<command-node>,
+  }
+
+  /// A command may dispatch to subcommands, run its own body, or both.
+  /// Globals declared here apply to this command's own body and to
+  /// every descendant subcommand body (recursive globals — "this level
+  /// and downward").
+  record command-node {
+    name:        string,
+    aliases:     list<string>,
+    doc:         doc,
+    globals:     globals,
+    subcommands: list<command-index>,
+    body:        option<command-body>,
+  }
+
+  record globals {
+    options: list<option-spec>,
+    %flags:  list<flag-spec>,
+  }
+
+  record command-body {
+    positionals: positionals,
+    options:     list<option-spec>,
+    %flags:      list<flag-spec>,
+    constraints: list<constraint>,
+    stdin:       option<stream-spec>,
+    stdout:      option<stream-spec>,
+    %result:     option<result-spec>,
+    errors:      list<error-case>,
+    annotations: option<command-annotations>,
+  }
+
+  /// Behavioral hints surfaced to MCP and other LLM-facing
+  /// surfaces. All four follow the MCP convention. When absent
+  /// the surface treats them as untrusted defaults
+  /// (`destructive: true`, `open-world: true`, `read-only: false`,
+  /// `idempotent: false`), per MCP guidance.
+  record command-annotations {
+    /// Tool performs no destructive updates; safe to call freely.
+    read-only:   bool,
+    /// Tool may delete or overwrite (default true per MCP semantics).
+    destructive: bool,
+    /// Repeated calls with the same input have the same effect.
+    idempotent:  bool,
+    /// Tool reaches outside the host's controlled environment
+    /// (network calls, external APIs, the open world).
+    open-world:  bool,
+  }
+
+  // Positionals (variadic only at the tail, structurally)
+  record positionals {
+    fixed: list<positional>,
+    tail:  option<tail-positional>,
+  }
+
+  record positional {
+    name:       string,
+    doc:        doc,
+    value-name: option<string>,
+    /// Index into `tool.schema`.
+    %type:      type-node-index,
+    /// Default value, interpreted against `%type` in `tool.schema`.
+    default:    option<schema-value-tree>,
+    required:   bool,
+    /// If true, the positional's value may be read from standard input
+    /// (e.g. grep's trailing `files` accepting piped input).
+    accepts-stdio: bool,
+  }
+
+  record tail-positional {
+    name:       string,
+    doc:        doc,
+    value-name: option<string>,
+    /// Index into `tool.schema`.
+    item-type:  type-node-index,
+    min:        u32,
+    max:        option<u32>,
+    /// Token required before tail items (e.g. "--" for `git log -- <paths>`).
+    separator:  option<string>,
+    /// If true, tokens after `separator` are not flag-parsed (for
+    /// `kubectl exec -- CMD ARGS...`).
+    verbatim:   bool,
+    /// If true, the tail items may be read from standard input
+    /// (e.g. grep's trailing `files` accepting piped input).
+    accepts-stdio: bool,
+  }
+
+  // Options and flags
+  record option-spec {
+    long:       string,
+    short:      option<char>,
+    aliases:    list<string>,
+    doc:        doc,
+    value-name: option<string>,
+    shape:      option-shape,
+    /// Default value, interpreted against the option's type node in
+    /// `tool.schema`.
+    default:    option<schema-value-tree>,
+    required:   bool,
+    env-var:    option<string>,
+  }
+
+  variant option-shape {
+    /// Required value: --opt VALUE or --opt=VALUE. Index into `tool.schema`.
+    scalar(type-node-index),
+    /// Bare presence collapses to `default`; with value parses normally
+    /// (--decorate, --signed[=mode], --force-with-lease[=ref]). Index into
+    /// `tool.schema`.
+    optional-scalar(type-node-index),
+    /// Repeatable scalar option (`-e a -e b`); the collected value is a
+    /// `list` of the element type.
+    repeatable-list(repeatable-list-shape),
+    /// Repeatable key-value option (`-c a=1 -c b=2`); the collected value is a
+    /// `golem:core` `map` node, never a `list<tuple>`.
+    repeatable-map(repeatable-map-shape),
+  }
+
+  record repeatable-list-shape {
+    repetition: repetition,
+    /// Index into `tool.schema`; the element type of the collected `list`.
+    item-type:  type-node-index,
+  }
+
+  record repeatable-map-shape {
+    repetition:           repetition,
+    /// Index into `tool.schema`; a `golem:core` `map` (key + value) node. The
+    /// collected value is this map.
+    map-type:             type-node-index,
+    /// What happens when the same key is supplied more than once.
+    duplicate-key-policy: duplicate-key-policy,
+  }
+
+  /// Resolution policy for a repeated key in a `repeatable-map` option.
+  enum duplicate-key-policy {
+    /// A repeated key is a usage error.
+    reject,
+    /// A repeated key takes the last supplied value.
+    last-wins,
+  }
+
+  variant repetition {
+    /// --inc a --inc b
+    repeated,
+    /// --inc=a,b
+    delimited(char),
+    /// Both surface forms accepted.
+    either(char),
+  }
+
+  record flag-spec {
+    long:    string,
+    short:   option<char>,
+    aliases: list<string>,
+    doc:     doc,
+    shape:   flag-shape,
+    env-var: option<string>,
+  }
+
+  variant flag-shape {
+    bool-flag(bool-flag-shape),
+    /// Counted flag (-vvv); optional max count.
+    count-flag(option<u32>),
+  }
+
+  record bool-flag-shape {
+    default:   bool,
+    /// If true, --no-<name> is auto-synthesized.
+    negatable: bool,
+  }
+
+  // Constraints
+  variant ref {
+    present(string),
+    value-is(value-is-ref),
+  }
+
+  record value-is-ref {
+    name:  string,
+    /// Literal value, interpreted against the declared type node of `name`
+    /// in `tool.schema`.
+    value: schema-value-tree,
+  }
+
+  variant constraint {
+    requires-all(list<ref>),
+    all-or-none(list<ref>),
+    requires-any(list<ref>),
+    mutex-groups(list<ref-group>),
+    implies(implies-c),
+    forbids(forbids-c),
+  }
+
+  record ref-group {
+    refs: list<ref>,
+  }
+
+  record implies-c {
+    lhs-quant: quantifier,
+    lhs:       list<ref>,
+    rhs-quant: quantifier,
+    rhs:       list<ref>,
+  }
+
+  record forbids-c {
+    lhs-quant: quantifier,
+    lhs:       list<ref>,
+    rhs:       list<ref>,
+  }
+
+  enum quantifier { all, any }
+
+  // Streams, structured results, errors
+  record stream-spec {
+    doc:      doc,
+    mime:     list<string>,
+    required: bool,
+  }
+
+  record result-spec {
+    /// Index into `tool.schema`.
+    %type:             type-node-index,
+    doc:               doc,
+    formatters:        list<formatter>,
+    default-formatter: string,
+  }
+
+  record formatter {
+    name: string,
+    doc:  doc,
+  }
+
+  record error-case {
+    name:      string,
+    doc:       doc,
+    kind:      error-kind,
+    exit-code: u8,
+    /// Index into `tool.schema`.
+    payload:   option<type-node-index>,
+  }
+
+  enum error-kind { usage-error, runtime-error }
+
+  // Documentation, examples
+  record doc {
+    summary:     string,
+    description: string,
+    examples:    list<example>,
+  }
+
+  record example {
+    title: string,
+    body:  string,
+  }
+
+  // Invocation contract — shared between guest and host
+  variant tool-error {
+    invalid-tool-name(string),
+    invalid-command-path(list<string>),
+    invalid-input(string),
+    constraint-violation(string),
+    /// Returned `invocation-result` does not match the body's
+    /// declared `result-spec` (e.g., the returned value's root type
+    /// does not match the body's declared result schema; see §6.1
+    /// transparency invariant).
+    invalid-result(string),
+    /// Tool-defined failure. Mirrors `golem:agent/common`'s
+    /// `agent-error::custom-error`: the payload is a self-contained
+    /// `typed-schema-value` carrying the error value. Producers SHOULD
+    /// shape it so its root type matches one of the body's declared
+    /// `error-case` payload types.
+    custom-error(typed-schema-value),
+  }
+
+  record invocation-result {
+    %result: option<typed-schema-value>,
+    stdout:  option<stream<u8>>,
+  }
+}
diff --git a/sdks/go/golem/wit/deps/golem-tool/guest.wit b/sdks/go/golem/wit/deps/golem-tool/guest.wit
new file mode 100644
index 0000000000..5de7d91af6
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-tool/guest.wit
@@ -0,0 +1,58 @@
+package golem:tool@0.1.0;
+
+/// Interface exported by a component that provides tools. The component
+/// declares which tools it exposes, supplies their metadata, and accepts
+/// invocations against a chosen leaf command of any tool.
+///
+/// Tools are stateless from the host's perspective: each invocation is
+/// independent. State accumulated by the underlying agent (file-system
+/// writes, config-store updates, etc.) persists per the agent's normal
+/// rules and is independent of the tool calling convention.
+interface guest {
+  use common.{tool, tool-error, invocation-result};
+  use golem:core/types@2.0.0.{typed-schema-value};
+  use golem:agent/common@2.0.0.{principal};
+
+  /// Enumerate the tools this component exposes. The returned metadata
+  /// is complete (full command tree and schema graph).
+  discover-tools: func() -> result<list<tool>, tool-error>;
+
+  /// Look up a single tool by name.
+  get-tool: func(name: string) -> result<tool, tool-error>;
+
+  /// Invoke a command of a tool.
+  ///
+  /// `command-path` selects the command body to execute. An empty list
+  /// targets the root command's body; non-empty lists walk the
+  /// `subcommands` field, each segment matching a `command-node.name`
+  /// or alias.
+  ///
+  /// `input` is a self-contained `typed-schema-value` whose root must
+  /// structurally match the selected body's input schema — a record with
+  /// one field per positional, option, flag, and inherited global declared
+  /// on or above the body, each field typed by the matching type node in
+  /// the body's schema.
+  ///
+  /// `stdin` is supplied when the selected body declared a stdin
+  /// `stream-spec`. The callee consumes the stream for the duration of the
+  /// call; dropping its reader closes further consumption.
+  ///
+  /// `principal` carries the caller's authenticated identity for
+  /// authorization and audit, identical in semantics to the parameter
+  /// of the same name in `golem:agent/guest.invoke`.
+  invoke: async func(
+    tool-name:    string,
+    command-path: list<string>,
+    input:        typed-schema-value,
+    stdin:        option<stream<u8>>,
+    principal:    principal,
+  ) -> result<invocation-result, tool-error>;
+}
+
+world tool-guest {
+  import golem:api/host@1.5.0;
+  import golem:agent/host@2.0.0;
+  import host;
+  import common;
+  export guest;
+}
diff --git a/sdks/go/golem/wit/deps/golem-tool/host.wit b/sdks/go/golem/wit/deps/golem-tool/host.wit
new file mode 100644
index 0000000000..961b51831c
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-tool/host.wit
@@ -0,0 +1,85 @@
+package golem:tool@0.1.0;
+
+/// Interface the runtime exposes to agents and tools for discovering and
+/// invoking ambient tools — tools registered by other components in the
+/// same Golem environment.
+///
+/// Mirrors the structure of `golem:agent/host`, but keyed on tool name
+/// (rather than agent-id), and without the agent-instance constructor
+/// step (tools are stateless invocables).
+interface host {
+  use common.{tool, tool-error, invocation-result};
+  use golem:core/types@2.0.0.{typed-schema-value, component-id};
+
+  /// A tool registered in the environment, addressable by name from
+  /// any agent or other tool. `definition` carries the full metadata;
+  /// `implemented-by` identifies the component that registers the
+  /// tool with the runtime — a Golem component exporting
+  /// `golem:tool/guest` for native tools, the runtime-internal
+  /// MCP-import bridge component for tools projected from
+  /// `mcp.imports` (§5.7.2), or the runtime itself (a synthesized
+  /// component-id) for host-implemented privileged tools (§4.6).
+  record registered-tool {
+    definition:     tool,
+    implemented-by: component-id,
+  }
+
+  /// Returns every tool **the calling agent has access to** in
+  /// the current environment, per the manifest's per-env and
+  /// per-agent binding rules (§5.6 / §6.4.3). The set returned
+  /// is exactly the set the calling agent could `tool-rpc.invoke`
+  /// against; tools the calling agent has no binding for are
+  /// excluded. Mirrors the *function shape* of
+  /// `golem:agent/host`'s `get-all-agent-types`, with the
+  /// addition of per-caller access filtering. Order is
+  /// unspecified; callers that
+  /// want a stable ordering should sort by
+  /// `definition.commands.nodes[0].name`.
+  get-all-tools: func() -> list<registered-tool>;
+
+  /// Returns the registered tool with the given name iff the
+  /// calling agent has access to it (per the same per-env and
+  /// per-agent binding rules as `get-all-tools`). Returns `none`
+  /// either if the tool is not registered or if the calling agent
+  /// has no binding for it; the two cases are not distinguished.
+  get-tool: func(name: string) -> option<registered-tool>;
+
+  variant rpc-error {
+    protocol-error(string),
+    denied(string),
+    not-found(string),
+    remote-internal-error(string),
+    remote-tool-error(tool-error),
+  }
+
+  resource tool-rpc {
+    constructor(tool-name: string);
+
+    invoke-and-await: async func(
+      command-path: list<string>,
+      input:        typed-schema-value,
+      stdin:        option<stream<u8>>,
+    ) -> result<invocation-result, rpc-error>;
+
+    invoke: func(
+      command-path: list<string>,
+      input:        typed-schema-value,
+      stdin:        option<stream<u8>>,
+    ) -> result<_, rpc-error>;
+
+    async-invoke-and-await: func(
+      command-path: list<string>,
+      input:        typed-schema-value,
+      stdin:        option<stream<u8>>,
+    ) -> future-invoke-result;
+  }
+
+  resource future-invoke-result {
+    get: async func() -> result<invocation-result, rpc-error>;
+    cancel: func();
+  }
+}
+
+world tool-host {
+  export host;
+}
diff --git a/sdks/go/golem/wit/deps/golem-websocket/websocket.wit b/sdks/go/golem/wit/deps/golem-websocket/websocket.wit
new file mode 100644
index 0000000000..b1ea481ef4
--- /dev/null
+++ b/sdks/go/golem/wit/deps/golem-websocket/websocket.wit
@@ -0,0 +1,46 @@
+package golem:websocket@1.5.0;
+
+interface client {
+  variant error {
+    connection-failure(string),
+    send-failure(string),
+    receive-failure(string),
+    protocol-error(string),
+    closed(option<close-info>),
+    other(string),
+  }
+
+  record close-info {
+    code: u16,
+    reason: string,
+  }
+
+  /// A WebSocket message — text or binary
+  variant message {
+    text(string),
+    binary(list<u8>),
+  }
+
+  /// A WebSocket connection resource
+  resource websocket-connection {
+    /// Connect to a WebSocket server at the given URL (ws:// or wss://)
+    /// Optional headers for auth, subprotocols, etc.
+    connect: static func(
+      url: string,
+      headers: option<list<tuple<string, string>>>
+    ) -> result<websocket-connection, error>;
+
+    /// Send a message (text or binary)
+    send: func(message: message) -> result<_, error>;
+
+    /// Receive the next message (blocks until available)
+    receive: async func() -> result<message, error>;
+
+    /// Receive the next message with a timeout in milliseconds.
+    /// Returns none if the timeout expires before a message arrives.
+    receive-with-timeout: async func(timeout-ms: u64) -> result<option<message>, error>;
+
+    /// Send a close frame with optional code and reason
+    close: func(code: option<u16>, reason: option<string>) -> result<_, error>;
+  }
+}
diff --git a/sdks/go/golem/wit/deps/http-0.2.6/http.wit b/sdks/go/golem/wit/deps/http-0.2.6/http.wit
new file mode 100644
index 0000000000..eb1b25f024
--- /dev/null
+++ b/sdks/go/golem/wit/deps/http-0.2.6/http.wit
@@ -0,0 +1,733 @@
+package wasi:http@0.2.6;
+
+/// This interface defines all of the types and methods for implementing
+/// HTTP Requests and Responses, both incoming and outgoing, as well as
+/// their headers, trailers, and bodies.
+@since(version = 0.2.0)
+interface types {
+  @since(version = 0.2.0)
+  use wasi:clocks/monotonic-clock@0.2.6.{duration};
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.6.{input-stream, output-stream};
+  @since(version = 0.2.0)
+  use wasi:io/error@0.2.6.{error as io-error};
+  @since(version = 0.2.0)
+  use wasi:io/poll@0.2.6.{pollable};
+
+  /// This type corresponds to HTTP standard Methods.
+  @since(version = 0.2.0)
+  variant method {
+    get,
+    head,
+    post,
+    put,
+    delete,
+    connect,
+    options,
+    trace,
+    patch,
+    other(string),
+  }
+
+  /// This type corresponds to HTTP standard Related Schemes.
+  @since(version = 0.2.0)
+  variant scheme {
+    HTTP,
+    HTTPS,
+    other(string),
+  }
+
+  /// Defines the case payload type for `DNS-error` above:
+  @since(version = 0.2.0)
+  record DNS-error-payload {
+    rcode: option<string>,
+    info-code: option<u16>,
+  }
+
+  /// Defines the case payload type for `TLS-alert-received` above:
+  @since(version = 0.2.0)
+  record TLS-alert-received-payload {
+    alert-id: option<u8>,
+    alert-message: option<string>,
+  }
+
+  /// Defines the case payload type for `HTTP-response-{header,trailer}-size` above:
+  @since(version = 0.2.0)
+  record field-size-payload {
+    field-name: option<string>,
+    field-size: option<u32>,
+  }
+
+  /// These cases are inspired by the IANA HTTP Proxy Error Types:
+  ///   <https://www.iana.org/assignments/http-proxy-status/http-proxy-status.xhtml#table-http-proxy-error-types>
+  @since(version = 0.2.0)
+  variant error-code {
+    DNS-timeout,
+    DNS-error(DNS-error-payload),
+    destination-not-found,
+    destination-unavailable,
+    destination-IP-prohibited,
+    destination-IP-unroutable,
+    connection-refused,
+    connection-terminated,
+    connection-timeout,
+    connection-read-timeout,
+    connection-write-timeout,
+    connection-limit-reached,
+    TLS-protocol-error,
+    TLS-certificate-error,
+    TLS-alert-received(TLS-alert-received-payload),
+    HTTP-request-denied,
+    HTTP-request-length-required,
+    HTTP-request-body-size(option<u64>),
+    HTTP-request-method-invalid,
+    HTTP-request-URI-invalid,
+    HTTP-request-URI-too-long,
+    HTTP-request-header-section-size(option<u32>),
+    HTTP-request-header-size(option<field-size-payload>),
+    HTTP-request-trailer-section-size(option<u32>),
+    HTTP-request-trailer-size(field-size-payload),
+    HTTP-response-incomplete,
+    HTTP-response-header-section-size(option<u32>),
+    HTTP-response-header-size(field-size-payload),
+    HTTP-response-body-size(option<u64>),
+    HTTP-response-trailer-section-size(option<u32>),
+    HTTP-response-trailer-size(field-size-payload),
+    HTTP-response-transfer-coding(option<string>),
+    HTTP-response-content-coding(option<string>),
+    HTTP-response-timeout,
+    HTTP-upgrade-failed,
+    HTTP-protocol-error,
+    loop-detected,
+    configuration-error,
+    /// This is a catch-all error for anything that doesn't fit cleanly into a
+    /// more specific case. It also includes an optional string for an
+    /// unstructured description of the error. Users should not depend on the
+    /// string for diagnosing errors, as it's not required to be consistent
+    /// between implementations.
+    internal-error(option<string>),
+  }
+
+  /// This type enumerates the different kinds of errors that may occur when
+  /// setting or appending to a `fields` resource.
+  @since(version = 0.2.0)
+  variant header-error {
+    /// This error indicates that a `field-name` or `field-value` was
+    /// syntactically invalid when used with an operation that sets headers in a
+    /// `fields`.
+    invalid-syntax,
+    /// This error indicates that a forbidden `field-name` was used when trying
+    /// to set a header in a `fields`.
+    forbidden,
+    /// This error indicates that the operation on the `fields` was not
+    /// permitted because the fields are immutable.
+    immutable,
+  }
+
+  /// Field keys are always strings.
+  ///
+  /// Field keys should always be treated as case insensitive by the `fields`
+  /// resource for the purposes of equality checking.
+  ///
+  /// # Deprecation
+  ///
+  /// This type has been deprecated in favor of the `field-name` type.
+  @since(version = 0.2.0)
+  @deprecated(version = 0.2.2)
+  type field-key = string;
+
+  /// Field names are always strings.
+  ///
+  /// Field names should always be treated as case insensitive by the `fields`
+  /// resource for the purposes of equality checking.
+  @since(version = 0.2.1)
+  type field-name = field-key;
+
+  /// Field values should always be ASCII strings. However, in
+  /// reality, HTTP implementations often have to interpret malformed values,
+  /// so they are provided as a list of bytes.
+  @since(version = 0.2.0)
+  type field-value = list<u8>;
+
+  /// This following block defines the `fields` resource which corresponds to
+  /// HTTP standard Fields. Fields are a common representation used for both
+  /// Headers and Trailers.
+  ///
+  /// A `fields` may be mutable or immutable. A `fields` created using the
+  /// constructor, `from-list`, or `clone` will be mutable, but a `fields`
+  /// resource given by other means (including, but not limited to,
+  /// `incoming-request.headers`, `outgoing-request.headers`) might be
+  /// immutable. In an immutable fields, the `set`, `append`, and `delete`
+  /// operations will fail with `header-error.immutable`.
+  @since(version = 0.2.0)
+  resource fields {
+    /// Construct an empty HTTP Fields.
+    ///
+    /// The resulting `fields` is mutable.
+    @since(version = 0.2.0)
+    constructor();
+    /// Construct an HTTP Fields.
+    ///
+    /// The resulting `fields` is mutable.
+    ///
+    /// The list represents each name-value pair in the Fields. Names
+    /// which have multiple values are represented by multiple entries in this
+    /// list with the same name.
+    ///
+    /// The tuple is a pair of the field name, represented as a string, and
+    /// Value, represented as a list of bytes.
+    ///
+    /// An error result will be returned if any `field-name` or `field-value` is
+    /// syntactically invalid, or if a field is forbidden.
+    @since(version = 0.2.0)
+    from-list: static func(entries: list<tuple<field-name, field-value>>) -> result<fields, header-error>;
+    /// Get all of the values corresponding to a name. If the name is not present
+    /// in this `fields` or is syntactically invalid, an empty list is returned.
+    /// However, if the name is present but empty, this is represented by a list
+    /// with one or more empty field-values present.
+    @since(version = 0.2.0)
+    get: func(name: field-name) -> list<field-value>;
+    /// Returns `true` when the name is present in this `fields`. If the name is
+    /// syntactically invalid, `false` is returned.
+    @since(version = 0.2.0)
+    has: func(name: field-name) -> bool;
+    /// Set all of the values for a name. Clears any existing values for that
+    /// name, if they have been set.
+    ///
+    /// Fails with `header-error.immutable` if the `fields` are immutable.
+    ///
+    /// Fails with `header-error.invalid-syntax` if the `field-name` or any of
+    /// the `field-value`s are syntactically invalid.
+    @since(version = 0.2.0)
+    set: func(name: field-name, value: list<field-value>) -> result<_, header-error>;
+    /// Delete all values for a name. Does nothing if no values for the name
+    /// exist.
+    ///
+    /// Fails with `header-error.immutable` if the `fields` are immutable.
+    ///
+    /// Fails with `header-error.invalid-syntax` if the `field-name` is
+    /// syntactically invalid.
+    @since(version = 0.2.0)
+    delete: func(name: field-name) -> result<_, header-error>;
+    /// Append a value for a name. Does not change or delete any existing
+    /// values for that name.
+    ///
+    /// Fails with `header-error.immutable` if the `fields` are immutable.
+    ///
+    /// Fails with `header-error.invalid-syntax` if the `field-name` or
+    /// `field-value` are syntactically invalid.
+    @since(version = 0.2.0)
+    append: func(name: field-name, value: field-value) -> result<_, header-error>;
+    /// Retrieve the full set of names and values in the Fields. Like the
+    /// constructor, the list represents each name-value pair.
+    ///
+    /// The outer list represents each name-value pair in the Fields. Names
+    /// which have multiple values are represented by multiple entries in this
+    /// list with the same name.
+    ///
+    /// The names and values are always returned in the original casing and in
+    /// the order in which they will be serialized for transport.
+    @since(version = 0.2.0)
+    entries: func() -> list<tuple<field-name, field-value>>;
+    /// Make a deep copy of the Fields. Equivalent in behavior to calling the
+    /// `fields` constructor on the return value of `entries`. The resulting
+    /// `fields` is mutable.
+    @since(version = 0.2.0)
+    clone: func() -> fields;
+  }
+
+  /// Headers is an alias for Fields.
+  @since(version = 0.2.0)
+  type headers = fields;
+
+  /// Trailers is an alias for Fields.
+  @since(version = 0.2.0)
+  type trailers = fields;
+
+  /// Represents an incoming HTTP Request.
+  @since(version = 0.2.0)
+  resource incoming-request {
+    /// Returns the method of the incoming request.
+    @since(version = 0.2.0)
+    method: func() -> method;
+    /// Returns the path with query parameters from the request, as a string.
+    @since(version = 0.2.0)
+    path-with-query: func() -> option<string>;
+    /// Returns the protocol scheme from the request.
+    @since(version = 0.2.0)
+    scheme: func() -> option<scheme>;
+    /// Returns the authority of the Request's target URI, if present.
+    @since(version = 0.2.0)
+    authority: func() -> option<string>;
+    /// Get the `headers` associated with the request.
+    ///
+    /// The returned `headers` resource is immutable: `set`, `append`, and
+    /// `delete` operations will fail with `header-error.immutable`.
+    ///
+    /// The `headers` returned are a child resource: it must be dropped before
+    /// the parent `incoming-request` is dropped. Dropping this
+    /// `incoming-request` before all children are dropped will trap.
+    @since(version = 0.2.0)
+    headers: func() -> headers;
+    /// Gives the `incoming-body` associated with this request. Will only
+    /// return success at most once, and subsequent calls will return error.
+    @since(version = 0.2.0)
+    consume: func() -> result<incoming-body>;
+  }
+
+  /// Represents an outgoing HTTP Request.
+  @since(version = 0.2.0)
+  resource outgoing-request {
+    /// Construct a new `outgoing-request` with a default `method` of `GET`, and
+    /// `none` values for `path-with-query`, `scheme`, and `authority`.
+    ///
+    /// * `headers` is the HTTP Headers for the Request.
+    ///
+    /// It is possible to construct, or manipulate with the accessor functions
+    /// below, an `outgoing-request` with an invalid combination of `scheme`
+    /// and `authority`, or `headers` which are not permitted to be sent.
+    /// It is the obligation of the `outgoing-handler.handle` implementation
+    /// to reject invalid constructions of `outgoing-request`.
+    @since(version = 0.2.0)
+    constructor(headers: headers);
+    /// Returns the resource corresponding to the outgoing Body for this
+    /// Request.
+    ///
+    /// Returns success on the first call: the `outgoing-body` resource for
+    /// this `outgoing-request` can be retrieved at most once. Subsequent
+    /// calls will return error.
+    @since(version = 0.2.0)
+    body: func() -> result<outgoing-body>;
+    /// Get the Method for the Request.
+    @since(version = 0.2.0)
+    method: func() -> method;
+    /// Set the Method for the Request. Fails if the string present in a
+    /// `method.other` argument is not a syntactically valid method.
+    @since(version = 0.2.0)
+    set-method: func(method: method) -> result;
+    /// Get the combination of the HTTP Path and Query for the Request.
+    /// When `none`, this represents an empty Path and empty Query.
+    @since(version = 0.2.0)
+    path-with-query: func() -> option<string>;
+    /// Set the combination of the HTTP Path and Query for the Request.
+    /// When `none`, this represents an empty Path and empty Query. Fails is the
+    /// string given is not a syntactically valid path and query uri component.
+    @since(version = 0.2.0)
+    set-path-with-query: func(path-with-query: option<string>) -> result;
+    /// Get the HTTP Related Scheme for the Request. When `none`, the
+    /// implementation may choose an appropriate default scheme.
+    @since(version = 0.2.0)
+    scheme: func() -> option<scheme>;
+    /// Set the HTTP Related Scheme for the Request. When `none`, the
+    /// implementation may choose an appropriate default scheme. Fails if the
+    /// string given is not a syntactically valid uri scheme.
+    @since(version = 0.2.0)
+    set-scheme: func(scheme: option<scheme>) -> result;
+    /// Get the authority of the Request's target URI. A value of `none` may be used
+    /// with Related Schemes which do not require an authority. The HTTP and
+    /// HTTPS schemes always require an authority.
+    @since(version = 0.2.0)
+    authority: func() -> option<string>;
+    /// Set the authority of the Request's target URI. A value of `none` may be used
+    /// with Related Schemes which do not require an authority. The HTTP and
+    /// HTTPS schemes always require an authority. Fails if the string given is
+    /// not a syntactically valid URI authority.
+    @since(version = 0.2.0)
+    set-authority: func(authority: option<string>) -> result;
+    /// Get the headers associated with the Request.
+    ///
+    /// The returned `headers` resource is immutable: `set`, `append`, and
+    /// `delete` operations will fail with `header-error.immutable`.
+    ///
+    /// This headers resource is a child: it must be dropped before the parent
+    /// `outgoing-request` is dropped, or its ownership is transferred to
+    /// another component by e.g. `outgoing-handler.handle`.
+    @since(version = 0.2.0)
+    headers: func() -> headers;
+  }
+
+  /// Parameters for making an HTTP Request. Each of these parameters is
+  /// currently an optional timeout applicable to the transport layer of the
+  /// HTTP protocol.
+  ///
+  /// These timeouts are separate from any the user may use to bound a
+  /// blocking call to `wasi:io/poll.poll`.
+  @since(version = 0.2.0)
+  resource request-options {
+    /// Construct a default `request-options` value.
+    @since(version = 0.2.0)
+    constructor();
+    /// The timeout for the initial connect to the HTTP Server.
+    @since(version = 0.2.0)
+    connect-timeout: func() -> option<duration>;
+    /// Set the timeout for the initial connect to the HTTP Server. An error
+    /// return value indicates that this timeout is not supported.
+    @since(version = 0.2.0)
+    set-connect-timeout: func(duration: option<duration>) -> result;
+    /// The timeout for receiving the first byte of the Response body.
+    @since(version = 0.2.0)
+    first-byte-timeout: func() -> option<duration>;
+    /// Set the timeout for receiving the first byte of the Response body. An
+    /// error return value indicates that this timeout is not supported.
+    @since(version = 0.2.0)
+    set-first-byte-timeout: func(duration: option<duration>) -> result;
+    /// The timeout for receiving subsequent chunks of bytes in the Response
+    /// body stream.
+    @since(version = 0.2.0)
+    between-bytes-timeout: func() -> option<duration>;
+    /// Set the timeout for receiving subsequent chunks of bytes in the Response
+    /// body stream. An error return value indicates that this timeout is not
+    /// supported.
+    @since(version = 0.2.0)
+    set-between-bytes-timeout: func(duration: option<duration>) -> result;
+  }
+
+  /// Represents the ability to send an HTTP Response.
+  ///
+  /// This resource is used by the `wasi:http/incoming-handler` interface to
+  /// allow a Response to be sent corresponding to the Request provided as the
+  /// other argument to `incoming-handler.handle`.
+  @since(version = 0.2.0)
+  resource response-outparam {
+    /// Send an HTTP 1xx response.
+    ///
+    /// Unlike `response-outparam.set`, this does not consume the
+    /// `response-outparam`, allowing the guest to send an arbitrary number of
+    /// informational responses before sending the final response using
+    /// `response-outparam.set`.
+    ///
+    /// This will return an `HTTP-protocol-error` if `status` is not in the
+    /// range [100-199], or an `internal-error` if the implementation does not
+    /// support informational responses.
+    @unstable(feature = informational-outbound-responses)
+    send-informational: func(status: u16, headers: headers) -> result<_, error-code>;
+    /// Set the value of the `response-outparam` to either send a response,
+    /// or indicate an error.
+    ///
+    /// This method consumes the `response-outparam` to ensure that it is
+    /// called at most once. If it is never called, the implementation
+    /// will respond with an error.
+    ///
+    /// The user may provide an `error` to `response` to allow the
+    /// implementation determine how to respond with an HTTP error response.
+    @since(version = 0.2.0)
+    set: static func(param: response-outparam, response: result<outgoing-response, error-code>);
+  }
+
+  /// This type corresponds to the HTTP standard Status Code.
+  @since(version = 0.2.0)
+  type status-code = u16;
+
+  /// Represents an incoming HTTP Response.
+  @since(version = 0.2.0)
+  resource incoming-response {
+    /// Returns the status code from the incoming response.
+    @since(version = 0.2.0)
+    status: func() -> status-code;
+    /// Returns the headers from the incoming response.
+    ///
+    /// The returned `headers` resource is immutable: `set`, `append`, and
+    /// `delete` operations will fail with `header-error.immutable`.
+    ///
+    /// This headers resource is a child: it must be dropped before the parent
+    /// `incoming-response` is dropped.
+    @since(version = 0.2.0)
+    headers: func() -> headers;
+    /// Returns the incoming body. May be called at most once. Returns error
+    /// if called additional times.
+    @since(version = 0.2.0)
+    consume: func() -> result<incoming-body>;
+  }
+
+  /// Represents an incoming HTTP Request or Response's Body.
+  ///
+  /// A body has both its contents - a stream of bytes - and a (possibly
+  /// empty) set of trailers, indicating that the full contents of the
+  /// body have been received. This resource represents the contents as
+  /// an `input-stream` and the delivery of trailers as a `future-trailers`,
+  /// and ensures that the user of this interface may only be consuming either
+  /// the body contents or waiting on trailers at any given time.
+  @since(version = 0.2.0)
+  resource incoming-body {
+    /// Returns the contents of the body, as a stream of bytes.
+    ///
+    /// Returns success on first call: the stream representing the contents
+    /// can be retrieved at most once. Subsequent calls will return error.
+    ///
+    /// The returned `input-stream` resource is a child: it must be dropped
+    /// before the parent `incoming-body` is dropped, or consumed by
+    /// `incoming-body.finish`.
+    ///
+    /// This invariant ensures that the implementation can determine whether
+    /// the user is consuming the contents of the body, waiting on the
+    /// `future-trailers` to be ready, or neither. This allows for network
+    /// backpressure is to be applied when the user is consuming the body,
+    /// and for that backpressure to not inhibit delivery of the trailers if
+    /// the user does not read the entire body.
+    @since(version = 0.2.0)
+    %stream: func() -> result<input-stream>;
+    /// Takes ownership of `incoming-body`, and returns a `future-trailers`.
+    /// This function will trap if the `input-stream` child is still alive.
+    @since(version = 0.2.0)
+    finish: static func(this: incoming-body) -> future-trailers;
+  }
+
+  /// Represents a future which may eventually return trailers, or an error.
+  ///
+  /// In the case that the incoming HTTP Request or Response did not have any
+  /// trailers, this future will resolve to the empty set of trailers once the
+  /// complete Request or Response body has been received.
+  @since(version = 0.2.0)
+  resource future-trailers {
+    /// Returns a pollable which becomes ready when either the trailers have
+    /// been received, or an error has occurred. When this pollable is ready,
+    /// the `get` method will return `some`.
+    @since(version = 0.2.0)
+    subscribe: func() -> pollable;
+    /// Returns the contents of the trailers, or an error which occurred,
+    /// once the future is ready.
+    ///
+    /// The outer `option` represents future readiness. Users can wait on this
+    /// `option` to become `some` using the `subscribe` method.
+    ///
+    /// The outer `result` is used to retrieve the trailers or error at most
+    /// once. It will be success on the first call in which the outer option
+    /// is `some`, and error on subsequent calls.
+    ///
+    /// The inner `result` represents that either the HTTP Request or Response
+    /// body, as well as any trailers, were received successfully, or that an
+    /// error occurred receiving them. The optional `trailers` indicates whether
+    /// or not trailers were present in the body.
+    ///
+    /// When some `trailers` are returned by this method, the `trailers`
+    /// resource is immutable, and a child. Use of the `set`, `append`, or
+    /// `delete` methods will return an error, and the resource must be
+    /// dropped before the parent `future-trailers` is dropped.
+    @since(version = 0.2.0)
+    get: func() -> option<result<result<option<trailers>, error-code>>>;
+  }
+
+  /// Represents an outgoing HTTP Response.
+  @since(version = 0.2.0)
+  resource outgoing-response {
+    /// Construct an `outgoing-response`, with a default `status-code` of `200`.
+    /// If a different `status-code` is needed, it must be set via the
+    /// `set-status-code` method.
+    ///
+    /// * `headers` is the HTTP Headers for the Response.
+    @since(version = 0.2.0)
+    constructor(headers: headers);
+    /// Get the HTTP Status Code for the Response.
+    @since(version = 0.2.0)
+    status-code: func() -> status-code;
+    /// Set the HTTP Status Code for the Response. Fails if the status-code
+    /// given is not a valid http status code.
+    @since(version = 0.2.0)
+    set-status-code: func(status-code: status-code) -> result;
+    /// Get the headers associated with the Request.
+    ///
+    /// The returned `headers` resource is immutable: `set`, `append`, and
+    /// `delete` operations will fail with `header-error.immutable`.
+    ///
+    /// This headers resource is a child: it must be dropped before the parent
+    /// `outgoing-request` is dropped, or its ownership is transferred to
+    /// another component by e.g. `outgoing-handler.handle`.
+    @since(version = 0.2.0)
+    headers: func() -> headers;
+    /// Returns the resource corresponding to the outgoing Body for this Response.
+    ///
+    /// Returns success on the first call: the `outgoing-body` resource for
+    /// this `outgoing-response` can be retrieved at most once. Subsequent
+    /// calls will return error.
+    @since(version = 0.2.0)
+    body: func() -> result<outgoing-body>;
+  }
+
+  /// Represents an outgoing HTTP Request or Response's Body.
+  ///
+  /// A body has both its contents - a stream of bytes - and a (possibly
+  /// empty) set of trailers, inducating the full contents of the body
+  /// have been sent. This resource represents the contents as an
+  /// `output-stream` child resource, and the completion of the body (with
+  /// optional trailers) with a static function that consumes the
+  /// `outgoing-body` resource, and ensures that the user of this interface
+  /// may not write to the body contents after the body has been finished.
+  ///
+  /// If the user code drops this resource, as opposed to calling the static
+  /// method `finish`, the implementation should treat the body as incomplete,
+  /// and that an error has occurred. The implementation should propagate this
+  /// error to the HTTP protocol by whatever means it has available,
+  /// including: corrupting the body on the wire, aborting the associated
+  /// Request, or sending a late status code for the Response.
+  @since(version = 0.2.0)
+  resource outgoing-body {
+    /// Returns a stream for writing the body contents.
+    ///
+    /// The returned `output-stream` is a child resource: it must be dropped
+    /// before the parent `outgoing-body` resource is dropped (or finished),
+    /// otherwise the `outgoing-body` drop or `finish` will trap.
+    ///
+    /// Returns success on the first call: the `output-stream` resource for
+    /// this `outgoing-body` may be retrieved at most once. Subsequent calls
+    /// will return error.
+    @since(version = 0.2.0)
+    write: func() -> result<output-stream>;
+    /// Finalize an outgoing body, optionally providing trailers. This must be
+    /// called to signal that the response is complete. If the `outgoing-body`
+    /// is dropped without calling `outgoing-body.finalize`, the implementation
+    /// should treat the body as corrupted.
+    ///
+    /// Fails if the body's `outgoing-request` or `outgoing-response` was
+    /// constructed with a Content-Length header, and the contents written
+    /// to the body (via `write`) does not match the value given in the
+    /// Content-Length.
+    @since(version = 0.2.0)
+    finish: static func(this: outgoing-body, trailers: option<trailers>) -> result<_, error-code>;
+  }
+
+  /// Represents a future which may eventually return an incoming HTTP
+  /// Response, or an error.
+  ///
+  /// This resource is returned by the `wasi:http/outgoing-handler` interface to
+  /// provide the HTTP Response corresponding to the sent Request.
+  @since(version = 0.2.0)
+  resource future-incoming-response {
+    /// Returns a pollable which becomes ready when either the Response has
+    /// been received, or an error has occurred. When this pollable is ready,
+    /// the `get` method will return `some`.
+    @since(version = 0.2.0)
+    subscribe: func() -> pollable;
+    /// Returns the incoming HTTP Response, or an error, once one is ready.
+    ///
+    /// The outer `option` represents future readiness. Users can wait on this
+    /// `option` to become `some` using the `subscribe` method.
+    ///
+    /// The outer `result` is used to retrieve the response or error at most
+    /// once. It will be success on the first call in which the outer option
+    /// is `some`, and error on subsequent calls.
+    ///
+    /// The inner `result` represents that either the incoming HTTP Response
+    /// status and headers have received successfully, or that an error
+    /// occurred. Errors may also occur while consuming the response body,
+    /// but those will be reported by the `incoming-body` and its
+    /// `output-stream` child.
+    @since(version = 0.2.0)
+    get: func() -> option<result<result<incoming-response, error-code>>>;
+  }
+
+  /// Attempts to extract a http-related `error` from the wasi:io `error`
+  /// provided.
+  ///
+  /// Stream operations which return
+  /// `wasi:io/stream/stream-error::last-operation-failed` have a payload of
+  /// type `wasi:io/error/error` with more information about the operation
+  /// that failed. This payload can be passed through to this function to see
+  /// if there's http-related information about the error to return.
+  ///
+  /// Note that this function is fallible because not all io-errors are
+  /// http-related errors.
+  @since(version = 0.2.0)
+  http-error-code: func(err: borrow<io-error>) -> option<error-code>;
+}
+
+/// This interface defines a handler of incoming HTTP Requests. It should
+/// be exported by components which can respond to HTTP Requests.
+@since(version = 0.2.0)
+interface incoming-handler {
+  @since(version = 0.2.0)
+  use types.{incoming-request, response-outparam};
+
+  /// This function is invoked with an incoming HTTP Request, and a resource
+  /// `response-outparam` which provides the capability to reply with an HTTP
+  /// Response. The response is sent by calling the `response-outparam.set`
+  /// method, which allows execution to continue after the response has been
+  /// sent. This enables both streaming to the response body, and performing other
+  /// work.
+  ///
+  /// The implementor of this function must write a response to the
+  /// `response-outparam` before returning, or else the caller will respond
+  /// with an error on its behalf.
+  @since(version = 0.2.0)
+  handle: func(request: incoming-request, response-out: response-outparam);
+}
+
+/// This interface defines a handler of outgoing HTTP Requests. It should be
+/// imported by components which wish to make HTTP Requests.
+@since(version = 0.2.0)
+interface outgoing-handler {
+  @since(version = 0.2.0)
+  use types.{outgoing-request, request-options, future-incoming-response, error-code};
+
+  /// This function is invoked with an outgoing HTTP Request, and it returns
+  /// a resource `future-incoming-response` which represents an HTTP Response
+  /// which may arrive in the future.
+  ///
+  /// The `options` argument accepts optional parameters for the HTTP
+  /// protocol's transport layer.
+  ///
+  /// This function may return an error if the `outgoing-request` is invalid
+  /// or not allowed to be made. Otherwise, protocol errors are reported
+  /// through the `future-incoming-response`.
+  @since(version = 0.2.0)
+  handle: func(request: outgoing-request, options: option<request-options>) -> result<future-incoming-response, error-code>;
+}
+
+/// The `wasi:http/imports` world imports all the APIs for HTTP proxies.
+/// It is intended to be `include`d in other worlds.
+@since(version = 0.2.0)
+world imports {
+  @since(version = 0.2.0)
+  import wasi:io/poll@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:clocks/monotonic-clock@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:clocks/wall-clock@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:random/random@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:io/error@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:io/streams@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:cli/stdout@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:cli/stderr@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:cli/stdin@0.2.6;
+  @since(version = 0.2.0)
+  import types;
+  @since(version = 0.2.0)
+  import outgoing-handler;
+}
+/// The `wasi:http/proxy` world captures a widely-implementable intersection of
+/// hosts that includes HTTP forward and reverse proxies. Components targeting
+/// this world may concurrently stream in and out any number of incoming and
+/// outgoing HTTP requests.
+@since(version = 0.2.0)
+world proxy {
+  @since(version = 0.2.0)
+  import wasi:io/poll@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:clocks/monotonic-clock@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:clocks/wall-clock@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:random/random@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:io/error@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:io/streams@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:cli/stdout@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:cli/stderr@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:cli/stdin@0.2.6;
+  @since(version = 0.2.0)
+  import types;
+  @since(version = 0.2.0)
+  import outgoing-handler;
+
+  @since(version = 0.2.0)
+  export incoming-handler;
+}
diff --git a/sdks/go/golem/wit/deps/http/http.wit b/sdks/go/golem/wit/deps/http/http.wit
new file mode 100644
index 0000000000..08458f7c68
--- /dev/null
+++ b/sdks/go/golem/wit/deps/http/http.wit
@@ -0,0 +1,509 @@
+package wasi:http@0.3.0;
+
+/// This interface defines all of the types and methods for implementing HTTP
+/// Requests and Responses, as well as their headers, trailers, and bodies.
+@since(version = 0.3.0)
+interface types {
+  use wasi:clocks/types@0.3.0.{duration};
+
+  /// This type corresponds to HTTP standard Methods.
+  @since(version = 0.3.0)
+  variant method {
+    get,
+    head,
+    post,
+    put,
+    delete,
+    connect,
+    options,
+    trace,
+    patch,
+    other(string),
+  }
+
+  /// This type corresponds to HTTP standard Related Schemes.
+  @since(version = 0.3.0)
+  variant scheme {
+    HTTP,
+    HTTPS,
+    other(string),
+  }
+
+  /// Defines the case payload type for `DNS-error` above:
+  @since(version = 0.3.0)
+  record DNS-error-payload {
+    rcode: option<string>,
+    info-code: option<u16>,
+  }
+
+  /// Defines the case payload type for `TLS-alert-received` above:
+  @since(version = 0.3.0)
+  record TLS-alert-received-payload {
+    alert-id: option<u8>,
+    alert-message: option<string>,
+  }
+
+  /// Defines the case payload type for `HTTP-response-{header,trailer}-size` above:
+  @since(version = 0.3.0)
+  record field-size-payload {
+    field-name: option<string>,
+    field-size: option<u32>,
+  }
+
+  /// These cases are inspired by the IANA HTTP Proxy Error Types:
+  ///   <https://www.iana.org/assignments/http-proxy-status/http-proxy-status.xhtml#table-http-proxy-error-types>
+  @since(version = 0.3.0)
+  variant error-code {
+    DNS-timeout,
+    DNS-error(DNS-error-payload),
+    destination-not-found,
+    destination-unavailable,
+    destination-IP-prohibited,
+    destination-IP-unroutable,
+    connection-refused,
+    connection-terminated,
+    connection-timeout,
+    connection-read-timeout,
+    connection-write-timeout,
+    connection-limit-reached,
+    TLS-protocol-error,
+    TLS-certificate-error,
+    TLS-alert-received(TLS-alert-received-payload),
+    HTTP-request-denied,
+    HTTP-request-length-required,
+    HTTP-request-body-size(option<u64>),
+    HTTP-request-method-invalid,
+    HTTP-request-URI-invalid,
+    HTTP-request-URI-too-long,
+    HTTP-request-header-section-size(option<u32>),
+    HTTP-request-header-size(option<field-size-payload>),
+    HTTP-request-trailer-section-size(option<u32>),
+    HTTP-request-trailer-size(field-size-payload),
+    HTTP-response-incomplete,
+    HTTP-response-header-section-size(option<u32>),
+    HTTP-response-header-size(field-size-payload),
+    HTTP-response-body-size(option<u64>),
+    HTTP-response-trailer-section-size(option<u32>),
+    HTTP-response-trailer-size(field-size-payload),
+    HTTP-response-transfer-coding(option<string>),
+    HTTP-response-content-coding(option<string>),
+    HTTP-response-timeout,
+    HTTP-upgrade-failed,
+    HTTP-protocol-error,
+    loop-detected,
+    configuration-error,
+    /// This is a catch-all error for anything that doesn't fit cleanly into a
+    /// more specific case. It also includes an optional string for an
+    /// unstructured description of the error. Users should not depend on the
+    /// string for diagnosing errors, as it's not required to be consistent
+    /// between implementations.
+    internal-error(option<string>),
+  }
+
+  /// This type enumerates the different kinds of errors that may occur when
+  /// setting or appending to a `fields` resource.
+  @since(version = 0.3.0)
+  variant header-error {
+    /// This error indicates that a `field-name` or `field-value` was
+    /// syntactically invalid when used with an operation that sets headers in a
+    /// `fields`.
+    invalid-syntax,
+    /// This error indicates that a forbidden `field-name` was used when trying
+    /// to set a header in a `fields`.
+    forbidden,
+    /// This error indicates that the operation on the `fields` was not
+    /// permitted because the fields are immutable.
+    immutable,
+    /// This error indicates that the operation would exceed an
+    /// implementation-defined limit on field sizes. This may apply to
+    /// an individual `field-value`, a single `field-name` plus all its
+    /// values, or the total aggregate size of all fields.
+    size-exceeded,
+    /// This is a catch-all error for anything that doesn't fit cleanly into a
+    /// more specific case. Implementations can use this to extend the error
+    /// type without breaking existing code. It also includes an optional
+    /// string for an unstructured description of the error. Users should not
+    /// depend on the string for diagnosing errors, as it's not required to be
+    /// consistent between implementations.
+    other(option<string>),
+  }
+
+  /// This type enumerates the different kinds of errors that may occur when
+  /// setting fields of a `request-options` resource.
+  @since(version = 0.3.0)
+  variant request-options-error {
+    /// Indicates the specified field is not supported by this implementation.
+    not-supported,
+    /// Indicates that the operation on the `request-options` was not permitted
+    /// because it is immutable.
+    immutable,
+    /// This is a catch-all error for anything that doesn't fit cleanly into a
+    /// more specific case. Implementations can use this to extend the error
+    /// type without breaking existing code. It also includes an optional
+    /// string for an unstructured description of the error. Users should not
+    /// depend on the string for diagnosing errors, as it's not required to be
+    /// consistent between implementations.
+    other(option<string>),
+  }
+
+  /// Field names are always strings.
+  ///
+  /// Field names should always be treated as case insensitive by the `fields`
+  /// resource for the purposes of equality checking.
+  @since(version = 0.3.0)
+  type field-name = string;
+
+  /// Field values should always be ASCII strings. However, in
+  /// reality, HTTP implementations often have to interpret malformed values,
+  /// so they are provided as a list of bytes.
+  @since(version = 0.3.0)
+  type field-value = list<u8>;
+
+  /// This following block defines the `fields` resource which corresponds to
+  /// HTTP standard Fields. Fields are a common representation used for both
+  /// Headers and Trailers.
+  ///
+  /// A `fields` may be mutable or immutable. A `fields` created using the
+  /// constructor, `from-list`, or `clone` will be mutable, but a `fields`
+  /// resource given by other means (including, but not limited to,
+  /// `request.headers`) might be be immutable. In an immutable fields, the
+  /// `set`, `append`, and `delete` operations will fail with
+  /// `header-error.immutable`.
+  ///
+  /// A `fields` resource should store `field-name`s and `field-value`s in their
+  /// original casing used to construct or mutate the `fields` resource. The `fields`
+  /// resource should use that original casing when serializing the fields for
+  /// transport or when returning them from a method.
+  ///
+  /// Implementations may impose limits on individual field values and on total
+  /// aggregate field section size. Operations that would exceed these limits
+  /// fail with `header-error.size-exceeded`
+  @since(version = 0.3.0)
+  resource fields {
+    /// Construct an empty HTTP Fields.
+    ///
+    /// The resulting `fields` is mutable.
+    constructor();
+    /// Construct an HTTP Fields.
+    ///
+    /// The resulting `fields` is mutable.
+    ///
+    /// The list represents each name-value pair in the Fields. Names
+    /// which have multiple values are represented by multiple entries in this
+    /// list with the same name.
+    ///
+    /// The tuple is a pair of the field name, represented as a string, and
+    /// Value, represented as a list of bytes. In a valid Fields, all names
+    /// and values are valid UTF-8 strings. However, values are not always
+    /// well-formed, so they are represented as a raw list of bytes.
+    ///
+    /// An error result will be returned if any header or value was
+    /// syntactically invalid, if a header was forbidden, or if the
+    /// entries would exceed an implementation size limit.
+    from-list: static func(entries: list<tuple<field-name, field-value>>) -> result<fields, header-error>;
+    /// Get all of the values corresponding to a name. If the name is not present
+    /// in this `fields`, an empty list is returned. However, if the name is
+    /// present but empty, this is represented by a list with one or more
+    /// empty field-values present.
+    get: func(name: field-name) -> list<field-value>;
+    /// Returns `true` when the name is present in this `fields`. If the name is
+    /// syntactically invalid, `false` is returned.
+    has: func(name: field-name) -> bool;
+    /// Set all of the values for a name. Clears any existing values for that
+    /// name, if they have been set.
+    ///
+    /// Fails with `header-error.immutable` if the `fields` are immutable.
+    ///
+    /// Fails with `header-error.size-exceeded` if the name or values would
+    /// exceed an implementation-defined size limit.
+    set: func(name: field-name, value: list<field-value>) -> result<_, header-error>;
+    /// Delete all values for a name. Does nothing if no values for the name
+    /// exist.
+    ///
+    /// Fails with `header-error.immutable` if the `fields` are immutable.
+    delete: func(name: field-name) -> result<_, header-error>;
+    /// Delete all values for a name. Does nothing if no values for the name
+    /// exist.
+    ///
+    /// Returns all values previously corresponding to the name, if any.
+    ///
+    /// Fails with `header-error.immutable` if the `fields` are immutable.
+    get-and-delete: func(name: field-name) -> result<list<field-value>, header-error>;
+    /// Append a value for a name. Does not change or delete any existing
+    /// values for that name.
+    ///
+    /// Fails with `header-error.immutable` if the `fields` are immutable.
+    ///
+    /// Fails with `header-error.size-exceeded` if the value would exceed
+    /// an implementation-defined size limit.
+    append: func(name: field-name, value: field-value) -> result<_, header-error>;
+    /// Retrieve the full set of names and values in the Fields. Like the
+    /// constructor, the list represents each name-value pair.
+    ///
+    /// The outer list represents each name-value pair in the Fields. Names
+    /// which have multiple values are represented by multiple entries in this
+    /// list with the same name.
+    ///
+    /// The names and values are always returned in the original casing and in
+    /// the order in which they will be serialized for transport.
+    copy-all: func() -> list<tuple<field-name, field-value>>;
+    /// Make a deep copy of the Fields. Equivalent in behavior to calling the
+    /// `fields` constructor on the return value of `copy-all`. The resulting
+    /// `fields` is mutable.
+    clone: func() -> fields;
+  }
+
+  /// Headers is an alias for Fields.
+  @since(version = 0.3.0)
+  type headers = fields;
+
+  /// Trailers is an alias for Fields.
+  @since(version = 0.3.0)
+  type trailers = fields;
+
+  /// Represents an HTTP Request.
+  @since(version = 0.3.0)
+  resource request {
+    /// Construct a new `request` with a default `method` of `GET`, and
+    /// `none` values for `path-with-query`, `scheme`, and `authority`.
+    ///
+    /// `headers` is the HTTP Headers for the Request.
+    ///
+    /// `contents` is the optional body content stream with `none`
+    /// representing a zero-length content stream.
+    /// Once it is closed, `trailers` future must resolve to a result.
+    /// If `trailers` resolves to an error, underlying connection
+    /// will be closed immediately.
+    ///
+    /// `options` is optional `request-options` resource to be used
+    /// if the request is sent over a network connection.
+    ///
+    /// It is possible to construct, or manipulate with the accessor functions
+    /// below, a `request` with an invalid combination of `scheme`
+    /// and `authority`, or `headers` which are not permitted to be sent.
+    /// It is the obligation of the `handler.handle` implementation
+    /// to reject invalid constructions of `request`.
+    ///
+    /// The returned future resolves to result of transmission of this request.
+    new: static func(headers: headers, contents: option<stream<u8>>, trailers: future<result<option<trailers>, error-code>>, options: option<request-options>) -> tuple<request, future<result<_, error-code>>>;
+    /// Get the Method for the Request.
+    get-method: func() -> method;
+    /// Set the Method for the Request. Fails if the string present in a
+    /// `method.other` argument is not a syntactically valid method.
+    set-method: func(method: method) -> result;
+    /// Get the combination of the HTTP Path and Query for the Request.  When
+    /// `none`, this represents an empty Path and empty Query.
+    get-path-with-query: func() -> option<string>;
+    /// Set the combination of the HTTP Path and Query for the Request.  When
+    /// `none`, this represents an empty Path and empty Query. Fails is the
+    /// string given is not a syntactically valid path and query uri component.
+    set-path-with-query: func(path-with-query: option<string>) -> result;
+    /// Get the HTTP Related Scheme for the Request. When `none`, the
+    /// implementation may choose an appropriate default scheme.
+    get-scheme: func() -> option<scheme>;
+    /// Set the HTTP Related Scheme for the Request. When `none`, the
+    /// implementation may choose an appropriate default scheme. Fails if the
+    /// string given is not a syntactically valid uri scheme.
+    set-scheme: func(scheme: option<scheme>) -> result;
+    /// Get the authority of the Request's target URI. A value of `none` may be used
+    /// with Related Schemes which do not require an authority. The HTTP and
+    /// HTTPS schemes always require an authority.
+    get-authority: func() -> option<string>;
+    /// Set the authority of the Request's target URI. A value of `none` may be used
+    /// with Related Schemes which do not require an authority. The HTTP and
+    /// HTTPS schemes always require an authority. Fails if the string given is
+    /// not a syntactically valid URI authority.
+    set-authority: func(authority: option<string>) -> result;
+    /// Get the `request-options` to be associated with this request
+    ///
+    /// The returned `request-options` resource is immutable: `set-*` operations
+    /// will fail if invoked.
+    ///
+    /// This `request-options` resource is a child: it must be dropped before
+    /// the parent `request` is dropped, or its ownership is transferred to
+    /// another component by e.g. `handler.handle`.
+    get-options: func() -> option<request-options>;
+    /// Get the headers associated with the Request.
+    ///
+    /// The returned `headers` resource is immutable: `set`, `append`, and
+    /// `delete` operations will fail with `header-error.immutable`.
+    get-headers: func() -> headers;
+    /// Get body of the Request.
+    ///
+    /// Stream returned by this method represents the contents of the body.
+    /// Once the stream is reported as closed, callers should await the returned
+    /// future to determine whether the body was received successfully.
+    /// The future will only resolve after the stream is reported as closed.
+    ///
+    /// This function takes a `res` future as a parameter, which can be used to
+    /// communicate an error in handling of the request.
+    ///
+    /// Note that function will move the `request`, but references to headers or
+    /// request options acquired from it previously will remain valid.
+    consume-body: static func(this: request, res: future<result<_, error-code>>) -> tuple<stream<u8>, future<result<option<trailers>, error-code>>>;
+  }
+
+  /// Parameters for making an HTTP Request. Each of these parameters is
+  /// currently an optional timeout applicable to the transport layer of the
+  /// HTTP protocol.
+  ///
+  /// These timeouts are separate from any the user may use to bound an
+  /// asynchronous call.
+  @since(version = 0.3.0)
+  resource request-options {
+    /// Construct a default `request-options` value.
+    constructor();
+    /// The timeout for the initial connect to the HTTP Server.
+    get-connect-timeout: func() -> option<duration>;
+    /// Set the timeout for the initial connect to the HTTP Server. An error
+    /// return value indicates that this timeout is not supported or that this
+    /// handle is immutable.
+    set-connect-timeout: func(duration: option<duration>) -> result<_, request-options-error>;
+    /// The timeout for receiving the first byte of the Response body.
+    get-first-byte-timeout: func() -> option<duration>;
+    /// Set the timeout for receiving the first byte of the Response body. An
+    /// error return value indicates that this timeout is not supported or that
+    /// this handle is immutable.
+    set-first-byte-timeout: func(duration: option<duration>) -> result<_, request-options-error>;
+    /// The timeout for receiving subsequent chunks of bytes in the Response
+    /// body stream.
+    get-between-bytes-timeout: func() -> option<duration>;
+    /// Set the timeout for receiving subsequent chunks of bytes in the Response
+    /// body stream. An error return value indicates that this timeout is not
+    /// supported or that this handle is immutable.
+    set-between-bytes-timeout: func(duration: option<duration>) -> result<_, request-options-error>;
+    /// Make a deep copy of the `request-options`.
+    /// The resulting `request-options` is mutable.
+    clone: func() -> request-options;
+  }
+
+  /// This type corresponds to the HTTP standard Status Code.
+  @since(version = 0.3.0)
+  type status-code = u16;
+
+  /// Represents an HTTP Response.
+  @since(version = 0.3.0)
+  resource response {
+    /// Construct a new `response`, with a default `status-code` of `200`.
+    /// If a different `status-code` is needed, it must be set via the
+    /// `set-status-code` method.
+    ///
+    /// `headers` is the HTTP Headers for the Response.
+    ///
+    /// `contents` is the optional body content stream with `none`
+    /// representing a zero-length content stream.
+    /// Once it is closed, `trailers` future must resolve to a result.
+    /// If `trailers` resolves to an error, underlying connection
+    /// will be closed immediately.
+    ///
+    /// The returned future resolves to result of transmission of this response.
+    new: static func(headers: headers, contents: option<stream<u8>>, trailers: future<result<option<trailers>, error-code>>) -> tuple<response, future<result<_, error-code>>>;
+    /// Get the HTTP Status Code for the Response.
+    get-status-code: func() -> status-code;
+    /// Set the HTTP Status Code for the Response. Fails if the status-code
+    /// given is not a valid http status code.
+    set-status-code: func(status-code: status-code) -> result;
+    /// Get the headers associated with the Response.
+    ///
+    /// The returned `headers` resource is immutable: `set`, `append`, and
+    /// `delete` operations will fail with `header-error.immutable`.
+    get-headers: func() -> headers;
+    /// Get body of the Response.
+    ///
+    /// Stream returned by this method represents the contents of the body.
+    /// Once the stream is reported as closed, callers should await the returned
+    /// future to determine whether the body was received successfully.
+    /// The future will only resolve after the stream is reported as closed.
+    ///
+    /// This function takes a `res` future as a parameter, which can be used to
+    /// communicate an error in handling of the response.
+    ///
+    /// Note that function will move the `response`, but references to headers
+    /// acquired from it previously will remain valid.
+    consume-body: static func(this: response, res: future<result<_, error-code>>) -> tuple<stream<u8>, future<result<option<trailers>, error-code>>>;
+  }
+}
+
+/// This interface defines a handler of HTTP Requests.
+///
+/// In a `wasi:http/service` this interface is exported to respond to an
+/// incoming HTTP Request with a Response.
+///
+/// In `wasi:http/middleware` this interface is both exported and imported as
+/// the "downstream" and "upstream" directions of the middleware chain.
+@since(version = 0.3.0)
+interface handler {
+  use types.{request, response, error-code};
+
+  /// This function may be called with either an incoming request read from the
+  /// network or a request synthesized or forwarded by another component.
+  handle: async func(request: request) -> result<response, error-code>;
+}
+
+/// This interface defines an HTTP client for sending "outgoing" requests.
+///
+/// Most components are expected to import this interface to provide the
+/// capability to send HTTP requests to arbitrary destinations on a network.
+///
+/// The type signature of `client.send` is the same as `handler.handle`. This
+/// duplication is currently necessary because some Component Model tooling
+/// (including WIT itself) is unable to represent a component importing two
+/// instances of the same interface. A `client.send` import may be linked
+/// directly to a `handler.handle` export to bypass the network.
+@since(version = 0.3.0)
+interface client {
+  use types.{request, response, error-code};
+
+  /// This function may be used to either send an outgoing request over the
+  /// network or to forward it to another component.
+  send: async func(request: request) -> result<response, error-code>;
+}
+
+/// The `wasi:http/service` world captures a broad category of HTTP services
+/// including web applications, API servers, and proxies. It may be `include`d
+/// in more specific worlds such as `wasi:http/middleware`.
+@since(version = 0.3.0)
+world service {
+  import wasi:cli/types@0.3.0;
+  import wasi:cli/stdout@0.3.0;
+  import wasi:cli/stderr@0.3.0;
+  import wasi:cli/stdin@0.3.0;
+  import wasi:clocks/types@0.3.0;
+  import types;
+  import client;
+  import wasi:clocks/monotonic-clock@0.3.0;
+  import wasi:clocks/system-clock@0.3.0;
+  @unstable(feature = clocks-timezone)
+  import wasi:clocks/timezone@0.3.0;
+  import wasi:random/random@0.3.0;
+  import wasi:random/insecure@0.3.0;
+  import wasi:random/insecure-seed@0.3.0;
+
+  export handler;
+}
+/// The `wasi:http/middleware` world captures HTTP services that forward HTTP
+/// Requests to another handler.
+///
+/// Components may implement this world to allow them to participate in handler
+/// "chains" where a `request` flows through handlers on its way to some terminal
+/// `service` and corresponding `response` flows in the opposite direction.
+@since(version = 0.3.0)
+world middleware {
+  import wasi:clocks/types@0.3.0;
+  import types;
+  import handler;
+  import wasi:cli/types@0.3.0;
+  import wasi:cli/stdout@0.3.0;
+  import wasi:cli/stderr@0.3.0;
+  import wasi:cli/stdin@0.3.0;
+  import client;
+  import wasi:clocks/monotonic-clock@0.3.0;
+  import wasi:clocks/system-clock@0.3.0;
+  @unstable(feature = clocks-timezone)
+  import wasi:clocks/timezone@0.3.0;
+  import wasi:random/random@0.3.0;
+  import wasi:random/insecure@0.3.0;
+  import wasi:random/insecure-seed@0.3.0;
+
+  export handler;
+}
diff --git a/sdks/go/golem/wit/deps/io-0.2.6/io.wit b/sdks/go/golem/wit/deps/io-0.2.6/io.wit
new file mode 100644
index 0000000000..08ad78e6b7
--- /dev/null
+++ b/sdks/go/golem/wit/deps/io-0.2.6/io.wit
@@ -0,0 +1,331 @@
+package wasi:io@0.2.6;
+
+@since(version = 0.2.0)
+interface error {
+  /// A resource which represents some error information.
+  ///
+  /// The only method provided by this resource is `to-debug-string`,
+  /// which provides some human-readable information about the error.
+  ///
+  /// In the `wasi:io` package, this resource is returned through the
+  /// `wasi:io/streams/stream-error` type.
+  ///
+  /// To provide more specific error information, other interfaces may
+  /// offer functions to "downcast" this error into more specific types. For example,
+  /// errors returned from streams derived from filesystem types can be described using
+  /// the filesystem's own error-code type. This is done using the function
+  /// `wasi:filesystem/types/filesystem-error-code`, which takes a `borrow<error>`
+  /// parameter and returns an `option<wasi:filesystem/types/error-code>`.
+  ///
+  /// The set of functions which can "downcast" an `error` into a more
+  /// concrete type is open.
+  @since(version = 0.2.0)
+  resource error {
+    /// Returns a string that is suitable to assist humans in debugging
+    /// this error.
+    ///
+    /// WARNING: The returned string should not be consumed mechanically!
+    /// It may change across platforms, hosts, or other implementation
+    /// details. Parsing this string is a major platform-compatibility
+    /// hazard.
+    @since(version = 0.2.0)
+    to-debug-string: func() -> string;
+  }
+}
+
+/// A poll API intended to let users wait for I/O events on multiple handles
+/// at once.
+@since(version = 0.2.0)
+interface poll {
+  /// `pollable` represents a single I/O event which may be ready, or not.
+  @since(version = 0.2.0)
+  resource pollable {
+    /// Return the readiness of a pollable. This function never blocks.
+    ///
+    /// Returns `true` when the pollable is ready, and `false` otherwise.
+    @since(version = 0.2.0)
+    ready: func() -> bool;
+    /// `block` returns immediately if the pollable is ready, and otherwise
+    /// blocks until ready.
+    ///
+    /// This function is equivalent to calling `poll.poll` on a list
+    /// containing only this pollable.
+    @since(version = 0.2.0)
+    block: func();
+  }
+
+  /// Poll for completion on a set of pollables.
+  ///
+  /// This function takes a list of pollables, which identify I/O sources of
+  /// interest, and waits until one or more of the events is ready for I/O.
+  ///
+  /// The result `list<u32>` contains one or more indices of handles in the
+  /// argument list that is ready for I/O.
+  ///
+  /// This function traps if either:
+  /// - the list is empty, or:
+  /// - the list contains more elements than can be indexed with a `u32` value.
+  ///
+  /// A timeout can be implemented by adding a pollable from the
+  /// wasi-clocks API to the list.
+  ///
+  /// This function does not return a `result`; polling in itself does not
+  /// do any I/O so it doesn't fail. If any of the I/O sources identified by
+  /// the pollables has an error, it is indicated by marking the source as
+  /// being ready for I/O.
+  @since(version = 0.2.0)
+  poll: func(in: list<borrow<pollable>>) -> list<u32>;
+}
+
+/// WASI I/O is an I/O abstraction API which is currently focused on providing
+/// stream types.
+///
+/// In the future, the component model is expected to add built-in stream types;
+/// when it does, they are expected to subsume this API.
+@since(version = 0.2.0)
+interface streams {
+  @since(version = 0.2.0)
+  use error.{error};
+  @since(version = 0.2.0)
+  use poll.{pollable};
+
+  /// An error for input-stream and output-stream operations.
+  @since(version = 0.2.0)
+  variant stream-error {
+    /// The last operation (a write or flush) failed before completion.
+    ///
+    /// More information is available in the `error` payload.
+    ///
+    /// After this, the stream will be closed. All future operations return
+    /// `stream-error::closed`.
+    last-operation-failed(error),
+    /// The stream is closed: no more input will be accepted by the
+    /// stream. A closed output-stream will return this error on all
+    /// future operations.
+    closed,
+  }
+
+  /// An input bytestream.
+  ///
+  /// `input-stream`s are *non-blocking* to the extent practical on underlying
+  /// platforms. I/O operations always return promptly; if fewer bytes are
+  /// promptly available than requested, they return the number of bytes promptly
+  /// available, which could even be zero. To wait for data to be available,
+  /// use the `subscribe` function to obtain a `pollable` which can be polled
+  /// for using `wasi:io/poll`.
+  @since(version = 0.2.0)
+  resource input-stream {
+    /// Perform a non-blocking read from the stream.
+    ///
+    /// When the source of a `read` is binary data, the bytes from the source
+    /// are returned verbatim. When the source of a `read` is known to the
+    /// implementation to be text, bytes containing the UTF-8 encoding of the
+    /// text are returned.
+    ///
+    /// This function returns a list of bytes containing the read data,
+    /// when successful. The returned list will contain up to `len` bytes;
+    /// it may return fewer than requested, but not more. The list is
+    /// empty when no bytes are available for reading at this time. The
+    /// pollable given by `subscribe` will be ready when more bytes are
+    /// available.
+    ///
+    /// This function fails with a `stream-error` when the operation
+    /// encounters an error, giving `last-operation-failed`, or when the
+    /// stream is closed, giving `closed`.
+    ///
+    /// When the caller gives a `len` of 0, it represents a request to
+    /// read 0 bytes. If the stream is still open, this call should
+    /// succeed and return an empty list, or otherwise fail with `closed`.
+    ///
+    /// The `len` parameter is a `u64`, which could represent a list of u8 which
+    /// is not possible to allocate in wasm32, or not desirable to allocate as
+    /// as a return value by the callee. The callee may return a list of bytes
+    /// less than `len` in size while more bytes are available for reading.
+    @since(version = 0.2.0)
+    read: func(len: u64) -> result<list<u8>, stream-error>;
+    /// Read bytes from a stream, after blocking until at least one byte can
+    /// be read. Except for blocking, behavior is identical to `read`.
+    @since(version = 0.2.0)
+    blocking-read: func(len: u64) -> result<list<u8>, stream-error>;
+    /// Skip bytes from a stream. Returns number of bytes skipped.
+    ///
+    /// Behaves identical to `read`, except instead of returning a list
+    /// of bytes, returns the number of bytes consumed from the stream.
+    @since(version = 0.2.0)
+    skip: func(len: u64) -> result<u64, stream-error>;
+    /// Skip bytes from a stream, after blocking until at least one byte
+    /// can be skipped. Except for blocking behavior, identical to `skip`.
+    @since(version = 0.2.0)
+    blocking-skip: func(len: u64) -> result<u64, stream-error>;
+    /// Create a `pollable` which will resolve once either the specified stream
+    /// has bytes available to read or the other end of the stream has been
+    /// closed.
+    /// The created `pollable` is a child resource of the `input-stream`.
+    /// Implementations may trap if the `input-stream` is dropped before
+    /// all derived `pollable`s created with this function are dropped.
+    @since(version = 0.2.0)
+    subscribe: func() -> pollable;
+  }
+
+  /// An output bytestream.
+  ///
+  /// `output-stream`s are *non-blocking* to the extent practical on
+  /// underlying platforms. Except where specified otherwise, I/O operations also
+  /// always return promptly, after the number of bytes that can be written
+  /// promptly, which could even be zero. To wait for the stream to be ready to
+  /// accept data, the `subscribe` function to obtain a `pollable` which can be
+  /// polled for using `wasi:io/poll`.
+  ///
+  /// Dropping an `output-stream` while there's still an active write in
+  /// progress may result in the data being lost. Before dropping the stream,
+  /// be sure to fully flush your writes.
+  @since(version = 0.2.0)
+  resource output-stream {
+    /// Check readiness for writing. This function never blocks.
+    ///
+    /// Returns the number of bytes permitted for the next call to `write`,
+    /// or an error. Calling `write` with more bytes than this function has
+    /// permitted will trap.
+    ///
+    /// When this function returns 0 bytes, the `subscribe` pollable will
+    /// become ready when this function will report at least 1 byte, or an
+    /// error.
+    @since(version = 0.2.0)
+    check-write: func() -> result<u64, stream-error>;
+    /// Perform a write. This function never blocks.
+    ///
+    /// When the destination of a `write` is binary data, the bytes from
+    /// `contents` are written verbatim. When the destination of a `write` is
+    /// known to the implementation to be text, the bytes of `contents` are
+    /// transcoded from UTF-8 into the encoding of the destination and then
+    /// written.
+    ///
+    /// Precondition: check-write gave permit of Ok(n) and contents has a
+    /// length of less than or equal to n. Otherwise, this function will trap.
+    ///
+    /// returns Err(closed) without writing if the stream has closed since
+    /// the last call to check-write provided a permit.
+    @since(version = 0.2.0)
+    write: func(contents: list<u8>) -> result<_, stream-error>;
+    /// Perform a write of up to 4096 bytes, and then flush the stream. Block
+    /// until all of these operations are complete, or an error occurs.
+    ///
+    /// This is a convenience wrapper around the use of `check-write`,
+    /// `subscribe`, `write`, and `flush`, and is implemented with the
+    /// following pseudo-code:
+    ///
+    /// ```text
+    /// let pollable = this.subscribe();
+    /// while !contents.is_empty() {
+    ///     // Wait for the stream to become writable
+    ///     pollable.block();
+    ///     let Ok(n) = this.check-write(); // eliding error handling
+    ///     let len = min(n, contents.len());
+    ///     let (chunk, rest) = contents.split_at(len);
+    ///     this.write(chunk  );            // eliding error handling
+    ///     contents = rest;
+    /// }
+    /// this.flush();
+    /// // Wait for completion of `flush`
+    /// pollable.block();
+    /// // Check for any errors that arose during `flush`
+    /// let _ = this.check-write();         // eliding error handling
+    /// ```
+    @since(version = 0.2.0)
+    blocking-write-and-flush: func(contents: list<u8>) -> result<_, stream-error>;
+    /// Request to flush buffered output. This function never blocks.
+    ///
+    /// This tells the output-stream that the caller intends any buffered
+    /// output to be flushed. the output which is expected to be flushed
+    /// is all that has been passed to `write` prior to this call.
+    ///
+    /// Upon calling this function, the `output-stream` will not accept any
+    /// writes (`check-write` will return `ok(0)`) until the flush has
+    /// completed. The `subscribe` pollable will become ready when the
+    /// flush has completed and the stream can accept more writes.
+    @since(version = 0.2.0)
+    flush: func() -> result<_, stream-error>;
+    /// Request to flush buffered output, and block until flush completes
+    /// and stream is ready for writing again.
+    @since(version = 0.2.0)
+    blocking-flush: func() -> result<_, stream-error>;
+    /// Create a `pollable` which will resolve once the output-stream
+    /// is ready for more writing, or an error has occurred. When this
+    /// pollable is ready, `check-write` will return `ok(n)` with n>0, or an
+    /// error.
+    ///
+    /// If the stream is closed, this pollable is always ready immediately.
+    ///
+    /// The created `pollable` is a child resource of the `output-stream`.
+    /// Implementations may trap if the `output-stream` is dropped before
+    /// all derived `pollable`s created with this function are dropped.
+    @since(version = 0.2.0)
+    subscribe: func() -> pollable;
+    /// Write zeroes to a stream.
+    ///
+    /// This should be used precisely like `write` with the exact same
+    /// preconditions (must use check-write first), but instead of
+    /// passing a list of bytes, you simply pass the number of zero-bytes
+    /// that should be written.
+    @since(version = 0.2.0)
+    write-zeroes: func(len: u64) -> result<_, stream-error>;
+    /// Perform a write of up to 4096 zeroes, and then flush the stream.
+    /// Block until all of these operations are complete, or an error
+    /// occurs.
+    ///
+    /// This is a convenience wrapper around the use of `check-write`,
+    /// `subscribe`, `write-zeroes`, and `flush`, and is implemented with
+    /// the following pseudo-code:
+    ///
+    /// ```text
+    /// let pollable = this.subscribe();
+    /// while num_zeroes != 0 {
+    ///     // Wait for the stream to become writable
+    ///     pollable.block();
+    ///     let Ok(n) = this.check-write(); // eliding error handling
+    ///     let len = min(n, num_zeroes);
+    ///     this.write-zeroes(len);         // eliding error handling
+    ///     num_zeroes -= len;
+    /// }
+    /// this.flush();
+    /// // Wait for completion of `flush`
+    /// pollable.block();
+    /// // Check for any errors that arose during `flush`
+    /// let _ = this.check-write();         // eliding error handling
+    /// ```
+    @since(version = 0.2.0)
+    blocking-write-zeroes-and-flush: func(len: u64) -> result<_, stream-error>;
+    /// Read from one stream and write to another.
+    ///
+    /// The behavior of splice is equivalent to:
+    /// 1. calling `check-write` on the `output-stream`
+    /// 2. calling `read` on the `input-stream` with the smaller of the
+    /// `check-write` permitted length and the `len` provided to `splice`
+    /// 3. calling `write` on the `output-stream` with that read data.
+    ///
+    /// Any error reported by the call to `check-write`, `read`, or
+    /// `write` ends the splice and reports that error.
+    ///
+    /// This function returns the number of bytes transferred; it may be less
+    /// than `len`.
+    @since(version = 0.2.0)
+    splice: func(src: borrow<input-stream>, len: u64) -> result<u64, stream-error>;
+    /// Read from one stream and write to another, with blocking.
+    ///
+    /// This is similar to `splice`, except that it blocks until the
+    /// `output-stream` is ready for writing, and the `input-stream`
+    /// is ready for reading, before performing the `splice`.
+    @since(version = 0.2.0)
+    blocking-splice: func(src: borrow<input-stream>, len: u64) -> result<u64, stream-error>;
+  }
+}
+
+@since(version = 0.2.0)
+world imports {
+  @since(version = 0.2.0)
+  import error;
+  @since(version = 0.2.0)
+  import poll;
+  @since(version = 0.2.0)
+  import streams;
+}
diff --git a/sdks/go/golem/wit/deps/keyvalue/caching.wit b/sdks/go/golem/wit/deps/keyvalue/caching.wit
new file mode 100644
index 0000000000..f5b497ef11
--- /dev/null
+++ b/sdks/go/golem/wit/deps/keyvalue/caching.wit
@@ -0,0 +1,87 @@
+// The `wasi:keyvalue/cache` interface defines the operations of a single
+// instance of a "cache", which is a non-durable, weakly-consistent key-value
+// store. "Non-durable" means that caches are allowed and expected to
+// arbitrarily discard key-value entries. "Weakly-consistent" means that there
+// are essentially no guarantees that operations will agree on their results: a
+// get following a set may not observe the set value; multiple gets may observe
+// different previous set values; etc. The only guarantee is that values are
+// not materialized "out of thin air": if a `get` returns a value, that value
+// was passed to a `set` operation at some point in time in the past.
+// Additionally, caches MUST make a best effort to respect the supplied
+// Time-to-Live values (within the usual limitations around time in a
+// distributed setting).
+interface cache {
+    use types.{key, incoming-value, outgoing-value, error};
+
+    // The `get` operation returns the value passed by a previous `set` for the
+    // same key within the given TTL or none if there is no such value.
+    get: func(k: key) -> future-get-result;
+
+    // Awaitable result of `get`. The inner `option` returns `none` when the
+    // requested key wasn't present.
+    resource future-get-result {
+        get: async func() -> result<option<incoming-value>, error>;
+    }
+
+    // The `exists` operation returns whether a value was previously `set` for
+    // the given key within the TTL.
+    exists: func(k: key) -> future-exists-result;
+
+    // Awaitable result of `exists`.
+    resource future-exists-result {
+        get: async func() -> result<bool, error>;
+    }
+
+    // The `set` operation sets the given value for the given key for the given
+    // time-to-live (TTL) duration, if supplied, specified in milliseconds. If
+    // a TTL is not supplied, the key may be kept indefinitely (as-if a very
+    // large TTL were used). If the key is already present in the cache, the
+    // value is updated in-place. In the common case of computing and caching a
+    // value if the given key is not already in the cache, consider using
+    // `get-or-set` (below) intead of separate `get` and `set` operations.
+    set: func(k: key, v: borrow<outgoing-value>, TTL-ms: option<u32>) -> future-result;
+
+    // Awaitable result of `set` and `delete`.
+    resource future-result {
+        get: async func() -> result<_, error>;
+    }
+
+    // The `get-or-set` operation asynchronously returns one of two cases
+    // enumerated by `get-or-set-entry`: in the `occupied` case, the given key
+    // already has a value present in the cache; in the `vacant` case, there
+    // was no value and the caller should write a value into the returned
+    // `vacancy`. This operation allows multiple concurrent `get-or-set`
+    // invocations to rendezvous such that only one invocation receives the
+    // `vacant` result while all other invocations wait until the vacancy is
+    // filled before receiving an `occupied` result. Implementations are not
+    // required to implement this rendezvous or to rendezvous in all possible
+    // cases.
+    variant get-or-set-entry {
+      occupied(incoming-value),
+      vacant(vacancy)
+    }
+    get-or-set: func(k: key) -> future-get-or-set-result;
+
+    // Awaitable result of `get-or-set`.
+    resource future-get-or-set-result {
+        get: async func() -> result<get-or-set-entry, error>;
+    }
+
+    // The following block defines the `vacancy` resource type. (When resource
+    // types are added, the `u32` type aliases can be replaced by proper
+    // `resource` types.) When the caller of `get-or-set` receives a `vacancy`,
+    // they must either call the `fill` method or drop the `vacancy` to
+    // indicate an error that prevents calling `fill`. An implementation MAY
+    // have a timeout that drops a vacancy that hasn't been filled in order
+    // to unblock other waiting `get-or-set` callers.
+    resource vacancy {
+        vacancy-fill: func(TTL-ms: option<u32>) -> outgoing-value;
+    }
+
+    // The `delete` operation removes any value with the given key from the
+    // cache. Like all cache operations, `delete` is weakly ordered and thus
+    // concurrent `get` calls may still see deleted keys for a period of time.
+    // Additionally, due to weak ordering, concurrent `set` calls for the same
+    // key may or may not get deleted.
+    delete: func(k: key) -> future-result;
+}
diff --git a/sdks/go/golem/wit/deps/keyvalue/error.wit b/sdks/go/golem/wit/deps/keyvalue/error.wit
new file mode 100644
index 0000000000..cd244f6fff
--- /dev/null
+++ b/sdks/go/golem/wit/deps/keyvalue/error.wit
@@ -0,0 +1,20 @@
+interface wasi-keyvalue-error {
+	/// An error resource type for keyvalue operations.
+	/// 
+	/// Common errors:
+	/// - Connectivity errors (e.g. network errors): when the client cannot establish
+	///  a connection to the keyvalue service.
+	/// - Authentication and Authorization errors: when the client fails to authenticate
+	///  or does not have the required permissions to perform the operation.
+	/// - Data errors: when the client sends incompatible or corrupted data.
+	/// - Resource errors: when the system runs out of resources (e.g. memory).
+	/// - Internal errors: unexpected errors on the server side.
+	/// 
+	/// Currently, this provides only one function to return a string representation
+	/// of the error. In the future, this will be extended to provide more information
+	/// about the error.
+	// Soon: switch to `resource error { ... }`
+	resource error {
+		trace: func() -> string;
+  	}
+}
\ No newline at end of file
diff --git a/sdks/go/golem/wit/deps/keyvalue/eventual-batch.wit b/sdks/go/golem/wit/deps/keyvalue/eventual-batch.wit
new file mode 100644
index 0000000000..080999eeaa
--- /dev/null
+++ b/sdks/go/golem/wit/deps/keyvalue/eventual-batch.wit
@@ -0,0 +1,81 @@
+/// A keyvalue interface that provides eventually consistent batch operations.
+/// 
+/// A batch operation is an operation that operates on multiple keys at once.
+/// 
+/// Batch operations are useful for reducing network round-trip time. For example, 
+/// if you want to get the values associated with 100 keys, you can either do 100 get
+/// operations or you can do 1 batch get operation. The batch operation is
+/// faster because it only needs to make 1 network call instead of 100.
+/// 
+/// A batch operation does not guarantee atomicity, meaning that if the batch
+/// operation fails, some of the keys may have been modified and some may not. 
+/// Transactional operations are being worked on and will be added in the future to
+/// provide atomicity.
+/// 
+/// Data consistency in a key value store refers to the gaurantee that once a 
+/// write operation completes, all subsequent read operations will return the
+/// value that was written.
+/// 
+/// The level of consistency in batch operations is **eventual consistency**, the same
+/// with the readwrite interface. This interface does not guarantee strong consistency, 
+/// meaning that if a write operation completes, subsequent read operations may not return
+/// the value that was written.
+interface eventual-batch {
+	/// A keyvalue interface that provides batch get operations.
+	use types.{bucket, error, key, incoming-value, outgoing-value};
+
+	/// Get the values associated with the keys in the bucket. It returns a list of
+	/// incoming-value that can be consumed to get the value associated with the key.
+	///
+	/// If any of the keys do not exist in the bucket, it returns a `none` value for
+	/// that key in the list.
+	/// 
+	/// Note that the key-value pairs are guaranteed to be returned in the same order
+	/// 
+	/// MAY show an out-of-date value if there are concurrent writes to the bucket.
+	/// 
+	/// If any other error occurs, it returns an `Err(error)`.
+	get-many: func(bucket: borrow<bucket>, keys: list<key>) -> result<list<option<incoming-value>>, error>;
+
+	/// Get all the keys in the bucket. It returns a list of keys.
+	/// 
+	/// Note that the keys are not guaranteed to be returned in any particular order.
+	/// 
+	/// If the bucket is empty, it returns an empty list.
+	/// 
+	/// MAY show an out-of-date list of keys if there are concurrent writes to the bucket.
+	/// 
+	/// If any error occurs, it returns an `Err(error)`.
+	keys: func(bucket: borrow<bucket>) -> result<list<key>, error>;
+
+	/// Set the values associated with the keys in the bucket. If the key already
+	/// exists in the bucket, it overwrites the value. 
+	/// 
+	/// Note that the key-value pairs are not guaranteed to be set in the order
+	/// they are provided. 
+	///
+	/// If any of the keys do not exist in the bucket, it creates a new key-value pair.
+	/// 
+	/// If any other error occurs, it returns an `Err(error)`. When an error occurs, it
+	/// does not rollback the key-value pairs that were already set. Thus, this batch operation 
+	/// does not guarantee atomicity, implying that some key-value pairs could be 
+	/// set while others might fail. 
+	/// 
+	/// Other concurrent operations may also be able to see the partial results.
+	set-many: func(bucket: borrow<bucket>, key-values: list<tuple<key, borrow<outgoing-value>>>) -> result<_, error>;
+
+	/// Delete the key-value pairs associated with the keys in the bucket.
+	/// 
+	/// Note that the key-value pairs are not guaranteed to be deleted in the order
+	/// they are provided.
+	/// 
+	/// If any of the keys do not exist in the bucket, it skips the key.
+	/// 
+	/// If any other error occurs, it returns an `Err(error)`. When an error occurs, it
+	/// does not rollback the key-value pairs that were already deleted. Thus, this batch operation
+	/// does not guarantee atomicity, implying that some key-value pairs could be
+	/// deleted while others might fail.
+	/// 
+	/// Other concurrent operations may also be able to see the partial results.
+	delete-many: func(bucket: borrow<bucket>, keys: list<key>) -> result<_, error>;
+}
\ No newline at end of file
diff --git a/sdks/go/golem/wit/deps/keyvalue/eventual.wit b/sdks/go/golem/wit/deps/keyvalue/eventual.wit
new file mode 100644
index 0000000000..e6e33cfe74
--- /dev/null
+++ b/sdks/go/golem/wit/deps/keyvalue/eventual.wit
@@ -0,0 +1,56 @@
+/// A keyvalue interface that provides eventually consistent CRUD operations.
+/// 
+/// A CRUD operation is an operation that acts on a single key-value pair.
+/// 
+/// The value in the key-value pair is defined as a `u8` byte array and the intention
+/// is that it is the common denominator for all data types defined by different
+/// key-value stores to handle data, ensuring compatibility between different
+/// key-value stores. Note: the clients will be expecting serialization/deserialization overhead
+/// to be handled by the key-value store. The value could be a serialized object from
+/// JSON, HTML or vendor-specific data types like AWS S3 objects.
+/// 
+/// Data consistency in a key value store refers to the gaurantee that once a 
+/// write operation completes, all subsequent read operations will return the
+/// value that was written.
+/// 
+/// The level of consistency in readwrite interfaces is **eventual consistency**,
+/// which means that if a write operation completes successfully, all subsequent
+/// read operations will eventually return the value that was written. In other words,
+/// if we pause the updates to the system, the system eventually will return 
+/// the last updated value for read.
+interface eventual {
+	/// A keyvalue interface that provides simple read and write operations.
+	use types.{bucket, error, incoming-value, key, outgoing-value};
+	
+	/// Get the value associated with the key in the bucket.
+	/// 
+	/// The value is returned as an option. If the key-value pair exists in the
+	/// bucket, it returns `Ok(value)`. If the key does not exist in the
+	/// bucket, it returns `Ok(none)`. 
+	///
+	/// If any other error occurs, it returns an `Err(error)`.
+	get: func(bucket: borrow<bucket>, key: key) -> result<option<incoming-value>, error>;
+
+	/// Set the value associated with the key in the bucket. If the key already
+	/// exists in the bucket, it overwrites the value.
+	///
+	/// If the key does not exist in the bucket, it creates a new key-value pair.
+	/// 
+	/// If any other error occurs, it returns an `Err(error)`.
+	set: func(bucket: borrow<bucket>, key: key, outgoing-value: borrow<outgoing-value>) -> result<_, error>;
+
+	/// Delete the key-value pair associated with the key in the bucket.
+	/// 
+	/// If the key does not exist in the bucket, it does nothing.
+	///
+	/// If any other error occurs, it returns an `Err(error)`.
+	delete: func(bucket: borrow<bucket>, key: key) -> result<_, error>;
+
+	/// Check if the key exists in the bucket.
+	/// 
+	/// If the key exists in the bucket, it returns `Ok(true)`. If the key does
+	/// not exist in the bucket, it returns `Ok(false)`.
+	/// 
+	/// If any other error occurs, it returns an `Err(error)`.
+	exists: func(bucket: borrow<bucket>, key: key) -> result<bool, error>;
+}
\ No newline at end of file
diff --git a/sdks/go/golem/wit/deps/keyvalue/handle-watch.wit b/sdks/go/golem/wit/deps/keyvalue/handle-watch.wit
new file mode 100644
index 0000000000..0ca7b37728
--- /dev/null
+++ b/sdks/go/golem/wit/deps/keyvalue/handle-watch.wit
@@ -0,0 +1,17 @@
+/// A keyvalue interface that provides handle-watch operations.
+/// 
+/// This interface is used to provide event-driven mechanisms to handle
+/// keyvalue changes.
+interface handle-watch {
+	/// A keyvalue interface that provides handle-watch operations.
+	use types.{bucket, key, incoming-value};
+
+	/// Handle the `set` event for the given bucket and key. 
+	/// It returns a `incoming-value` that represents the new value being set.
+	/// The new value can be consumed by the handler.
+	on-set: func(bucket: bucket, key: key, incoming-value: borrow<incoming-value>);
+
+	/// Handle the `delete` event for the given bucket and key.
+	/// It returns a `key` that represents the key being deleted.
+	on-delete: func(bucket: bucket, key: key);
+}
\ No newline at end of file
diff --git a/sdks/go/golem/wit/deps/keyvalue/types.wit b/sdks/go/golem/wit/deps/keyvalue/types.wit
new file mode 100644
index 0000000000..199c4cd0de
--- /dev/null
+++ b/sdks/go/golem/wit/deps/keyvalue/types.wit
@@ -0,0 +1,67 @@
+// A generic keyvalue interface for WASI.
+interface types {
+	/// A bucket is a collection of key-value pairs. Each key-value pair is stored
+	/// as a entry in the bucket, and the bucket itself acts as a collection of all
+	/// these entries.
+	///
+	/// It is worth noting that the exact terminology for bucket in key-value stores
+	/// can very depending on the specific implementation. For example,
+	/// 1. Amazon DynamoDB calls a collection of key-value pairs a table
+	/// 2. Redis has hashes, sets, and sorted sets as different types of collections
+	/// 3. Cassandra calls a collection of key-value pairs a column family
+	/// 4. MongoDB calls a collection of key-value pairs a collection
+	/// 5. Riak calls a collection of key-value pairs a bucket
+	/// 6. Memcached calls a collection of key-value pairs a slab
+	/// 7. Azure Cosmos DB calls a collection of key-value pairs a container
+	///
+	/// In this interface, we use the term `bucket` to refer to a collection of key-value
+	// Soon: switch to `resource bucket { ... }`
+	resource bucket {
+		/// Opens a bucket with the given name.
+		///
+		/// If any error occurs, including if the bucket does not exist, it returns an `Err(error)`.
+		open-bucket: static func(name: string) -> result<bucket, error>;
+  	}
+	/// A key is a unique identifier for a value in a bucket. The key is used to
+	/// retrieve the value from the bucket.
+	type key = string;
+
+	use wasi-keyvalue-error.{ error };
+	/// A value is the data stored in a key-value pair. The value can be of any type
+	/// that can be represented in a byte array.
+	// Soon: switch to `resource value { ... }`
+	resource outgoing-value {
+		new-outgoing-value: static func() -> outgoing-value;
+		/// Writes the value asynchronously by consuming the given `stream<u8>`:
+		/// the caller keeps the writable end and the host appends every received
+		/// byte to the outgoing value's body.
+		/// If any other error occurs, it returns an `Err(error)`.
+		outgoing-value-write-body-async: func(data: stream<u8>) -> result<_, error>;
+		/// Writes the value synchronously.
+		/// If any other error occurs, it returns an `Err(error)`.
+		outgoing-value-write-body-sync: func(value: list<u8>) -> result<_, error>;
+	}
+
+	/// A incoming-value is a wrapper around a value. It provides ways to read the value.
+	///
+	/// The incoming-value provides two ways to consume the value:
+	/// 1. `incoming-value-consume-sync` consumes the value synchronously and returns the
+	///    value as a `list<u8>`.
+	/// 2. `incoming-value-consume-async` consumes the value asynchronously and returns the
+	///    value as a `stream<u8>`.
+	/// In addition, it provides a `incoming-value-size` function to get the size of the value.
+	/// This is useful when the value is large and the caller wants to allocate a buffer of
+	/// the right size to consume the value.
+	// Soon: switch to `resource incoming-value { ... }`
+	resource incoming-value {
+		/// Consumes the value synchronously and returns the value as a list of bytes.
+		/// If any other error occurs, it returns an `Err(error)`.
+    	incoming-value-consume-sync: func() -> result<list<u8>, error>;
+		/// Consumes the value asynchronously and returns the value as a `stream<u8>`.
+		/// If any other error occurs, it returns an `Err(error)`.
+	    incoming-value-consume-async: func() -> result<stream<u8>, error>;
+		/// The size of the value in bytes.
+		/// If the size is unknown or unavailable, this function returns an `Err(error)`.
+	    incoming-value-size: func() -> result<u64, error>;
+	}
+}
diff --git a/sdks/go/golem/wit/deps/keyvalue/world.wit b/sdks/go/golem/wit/deps/keyvalue/world.wit
new file mode 100644
index 0000000000..bc556f70db
--- /dev/null
+++ b/sdks/go/golem/wit/deps/keyvalue/world.wit
@@ -0,0 +1,21 @@
+package wasi:keyvalue@0.1.0;
+
+/// The `wasi:keyvalue/imports` world provides common APIs for interacting
+/// with key-value stores. Components targeting this world will be able to
+/// do 
+/// 1. CRUD (create, read, update, delete) operations on key-value stores.
+/// 2. Batch operations that can reduce the number of round trips to the network.
+world imports {
+	/// The `eventual` capability allows the component to perform 
+	/// eventually consistent CRUD operations on the key-value store.
+	import eventual;
+
+	/// The `eventual-batch` capability allows the component to perform eventually
+	/// consistent batch operations that can reduce the number of round trips to the network.
+	import eventual-batch;
+}
+
+world keyvalue-handle-watch {
+	include imports;
+	export handle-watch;
+}
\ No newline at end of file
diff --git a/sdks/go/golem/wit/deps/logging/logging.wit b/sdks/go/golem/wit/deps/logging/logging.wit
new file mode 100644
index 0000000000..adb5ee5fb2
--- /dev/null
+++ b/sdks/go/golem/wit/deps/logging/logging.wit
@@ -0,0 +1,37 @@
+package wasi:logging;
+
+/// WASI Logging is a logging API intended to let users emit log messages with
+/// simple priority levels and context values.
+interface logging {
+    /// A log level, describing a kind of message.
+    enum level {
+       /// Describes messages about the values of variables and the flow of
+       /// control within a program.
+       trace,
+
+       /// Describes messages likely to be of interest to someone debugging a
+       /// program.
+       debug,
+
+       /// Describes messages likely to be of interest to someone monitoring a
+       /// program.
+       info,
+
+       /// Describes messages indicating hazardous situations.
+       warn,
+
+       /// Describes messages indicating serious errors.
+       error,
+
+       /// Describes messages indicating fatal errors.
+       critical,
+    }
+
+    /// Emit a log message.
+    ///
+    /// A log message has a `level` describing what kind of message is being
+    /// sent, a context, which is an uninterpreted string meant to help
+    /// consumers group similar messages, and a string containing the message
+    /// text.
+    log: func(level: level, context: string, message: string);
+}
\ No newline at end of file
diff --git a/sdks/go/golem/wit/deps/random-0.2.6/random.wit b/sdks/go/golem/wit/deps/random-0.2.6/random.wit
new file mode 100644
index 0000000000..73edf5b60e
--- /dev/null
+++ b/sdks/go/golem/wit/deps/random-0.2.6/random.wit
@@ -0,0 +1,92 @@
+package wasi:random@0.2.6;
+
+/// The insecure-seed interface for seeding hash-map DoS resistance.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+@since(version = 0.2.0)
+interface insecure-seed {
+  /// Return a 128-bit value that may contain a pseudo-random value.
+  ///
+  /// The returned value is not required to be computed from a CSPRNG, and may
+  /// even be entirely deterministic. Host implementations are encouraged to
+  /// provide pseudo-random values to any program exposed to
+  /// attacker-controlled content, to enable DoS protection built into many
+  /// languages' hash-map implementations.
+  ///
+  /// This function is intended to only be called once, by a source language
+  /// to initialize Denial Of Service (DoS) protection in its hash-map
+  /// implementation.
+  ///
+  /// # Expected future evolution
+  ///
+  /// This will likely be changed to a value import, to prevent it from being
+  /// called multiple times and potentially used for purposes other than DoS
+  /// protection.
+  @since(version = 0.2.0)
+  insecure-seed: func() -> tuple<u64, u64>;
+}
+
+/// The insecure interface for insecure pseudo-random numbers.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+@since(version = 0.2.0)
+interface insecure {
+  /// Return `len` insecure pseudo-random bytes.
+  ///
+  /// This function is not cryptographically secure. Do not use it for
+  /// anything related to security.
+  ///
+  /// There are no requirements on the values of the returned bytes, however
+  /// implementations are encouraged to return evenly distributed values with
+  /// a long period.
+  @since(version = 0.2.0)
+  get-insecure-random-bytes: func(len: u64) -> list<u8>;
+
+  /// Return an insecure pseudo-random `u64` value.
+  ///
+  /// This function returns the same type of pseudo-random data as
+  /// `get-insecure-random-bytes`, represented as a `u64`.
+  @since(version = 0.2.0)
+  get-insecure-random-u64: func() -> u64;
+}
+
+/// WASI Random is a random data API.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+@since(version = 0.2.0)
+interface random {
+  /// Return `len` cryptographically-secure random or pseudo-random bytes.
+  ///
+  /// This function must produce data at least as cryptographically secure and
+  /// fast as an adequately seeded cryptographically-secure pseudo-random
+  /// number generator (CSPRNG). It must not block, from the perspective of
+  /// the calling program, under any circumstances, including on the first
+  /// request and on requests for numbers of bytes. The returned data must
+  /// always be unpredictable.
+  ///
+  /// This function must always return fresh data. Deterministic environments
+  /// must omit this function, rather than implementing it with deterministic
+  /// data.
+  @since(version = 0.2.0)
+  get-random-bytes: func(len: u64) -> list<u8>;
+
+  /// Return a cryptographically-secure random or pseudo-random `u64` value.
+  ///
+  /// This function returns the same type of data as `get-random-bytes`,
+  /// represented as a `u64`.
+  @since(version = 0.2.0)
+  get-random-u64: func() -> u64;
+}
+
+@since(version = 0.2.0)
+world imports {
+  @since(version = 0.2.0)
+  import random;
+  @since(version = 0.2.0)
+  import insecure;
+  @since(version = 0.2.0)
+  import insecure-seed;
+}
diff --git a/sdks/go/golem/wit/deps/random/random.wit b/sdks/go/golem/wit/deps/random/random.wit
new file mode 100644
index 0000000000..0b9a55fc09
--- /dev/null
+++ b/sdks/go/golem/wit/deps/random/random.wit
@@ -0,0 +1,107 @@
+package wasi:random@0.3.0;
+
+/// The insecure-seed interface for seeding hash-map DoS resistance.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+@since(version = 0.3.0)
+interface insecure-seed {
+  /// Return a 128-bit value that may contain a pseudo-random value.
+  ///
+  /// The returned value is not required to be computed from a CSPRNG, and may
+  /// even be entirely deterministic. Host implementations are encouraged to
+  /// provide pseudo-random values to any program exposed to
+  /// attacker-controlled content, to enable DoS protection built into many
+  /// languages' hash-map implementations.
+  ///
+  /// This function is intended to only be called once, by a source language
+  /// to initialize Denial Of Service (DoS) protection in its hash-map
+  /// implementation.
+  ///
+  /// # Expected future evolution
+  ///
+  /// This will likely be changed to a value import, to prevent it from being
+  /// called multiple times and potentially used for purposes other than DoS
+  /// protection.
+  @since(version = 0.3.0)
+  get-insecure-seed: func() -> tuple<u64, u64>;
+}
+
+/// The insecure interface for insecure pseudo-random numbers.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+@since(version = 0.3.0)
+interface insecure {
+  /// Return up to `max-len` insecure pseudo-random bytes.
+  ///
+  /// This function is not cryptographically secure. Do not use it for
+  /// anything related to security.
+  ///
+  /// There are no requirements on the values of the returned bytes, however
+  /// implementations are encouraged to return evenly distributed values with
+  /// a long period.
+  ///
+  /// Implementations MAY return fewer bytes than requested (a short read).
+  /// Callers that require exactly `max-len` bytes MUST call this function in
+  /// a loop until the desired number of bytes has been accumulated.
+  /// Implementations MUST return at least 1 byte when `max-len` is greater
+  /// than zero. When `max-len` is zero, implementations MUST return an empty
+  /// list without trapping.
+  @since(version = 0.3.0)
+  get-insecure-random-bytes: func(max-len: u64) -> list<u8>;
+
+  /// Return an insecure pseudo-random `u64` value.
+  ///
+  /// This function returns the same type of pseudo-random data as
+  /// `get-insecure-random-bytes`, represented as a `u64`.
+  @since(version = 0.3.0)
+  get-insecure-random-u64: func() -> u64;
+}
+
+/// WASI Random is a random data API.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+@since(version = 0.3.0)
+interface random {
+  /// Return up to `max-len` cryptographically-secure random or pseudo-random
+  /// bytes.
+  ///
+  /// This function must produce data at least as cryptographically secure and
+  /// fast as an adequately seeded cryptographically-secure pseudo-random
+  /// number generator (CSPRNG). It must not block, from the perspective of
+  /// the calling program, under any circumstances, including on the first
+  /// request and on requests for numbers of bytes. The returned data must
+  /// always be unpredictable.
+  ///
+  /// Implementations MAY return fewer bytes than requested (a short read).
+  /// Callers that require exactly `max-len` bytes MUST call this function in
+  /// a loop until the desired number of bytes has been accumulated.
+  /// Implementations MUST return at least 1 byte when `max-len` is greater
+  /// than zero. When `max-len` is zero, implementations MUST return an empty
+  /// list without trapping.
+  ///
+  /// This function must always return fresh data. Deterministic environments
+  /// must omit this function, rather than implementing it with deterministic
+  /// data.
+  @since(version = 0.3.0)
+  get-random-bytes: func(max-len: u64) -> list<u8>;
+
+  /// Return a cryptographically-secure random or pseudo-random `u64` value.
+  ///
+  /// This function returns the same type of data as `get-random-bytes`,
+  /// represented as a `u64`.
+  @since(version = 0.3.0)
+  get-random-u64: func() -> u64;
+}
+
+@since(version = 0.3.0)
+world imports {
+  @since(version = 0.3.0)
+  import random;
+  @since(version = 0.3.0)
+  import insecure;
+  @since(version = 0.3.0)
+  import insecure-seed;
+}
diff --git a/sdks/go/golem/wit/deps/sockets-0.2.6/sockets.wit b/sdks/go/golem/wit/deps/sockets-0.2.6/sockets.wit
new file mode 100644
index 0000000000..db6d1a23b4
--- /dev/null
+++ b/sdks/go/golem/wit/deps/sockets-0.2.6/sockets.wit
@@ -0,0 +1,949 @@
+package wasi:sockets@0.2.6;
+
+@since(version = 0.2.0)
+interface network {
+  @unstable(feature = network-error-code)
+  use wasi:io/error@0.2.6.{error};
+
+  /// An opaque resource that represents access to (a subset of) the network.
+  /// This enables context-based security for networking.
+  /// There is no need for this to map 1:1 to a physical network interface.
+  @since(version = 0.2.0)
+  resource network;
+
+  /// Error codes.
+  ///
+  /// In theory, every API can return any error code.
+  /// In practice, API's typically only return the errors documented per API
+  /// combined with a couple of errors that are always possible:
+  /// - `unknown`
+  /// - `access-denied`
+  /// - `not-supported`
+  /// - `out-of-memory`
+  /// - `concurrency-conflict`
+  ///
+  /// See each individual API for what the POSIX equivalents are. They sometimes differ per API.
+  @since(version = 0.2.0)
+  enum error-code {
+    /// Unknown error
+    unknown,
+    /// Access denied.
+    ///
+    /// POSIX equivalent: EACCES, EPERM
+    access-denied,
+    /// The operation is not supported.
+    ///
+    /// POSIX equivalent: EOPNOTSUPP
+    not-supported,
+    /// One of the arguments is invalid.
+    ///
+    /// POSIX equivalent: EINVAL
+    invalid-argument,
+    /// Not enough memory to complete the operation.
+    ///
+    /// POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY
+    out-of-memory,
+    /// The operation timed out before it could finish completely.
+    timeout,
+    /// This operation is incompatible with another asynchronous operation that is already in progress.
+    ///
+    /// POSIX equivalent: EALREADY
+    concurrency-conflict,
+    /// Trying to finish an asynchronous operation that:
+    /// - has not been started yet, or:
+    /// - was already finished by a previous `finish-*` call.
+    ///
+    /// Note: this is scheduled to be removed when `future`s are natively supported.
+    not-in-progress,
+    /// The operation has been aborted because it could not be completed immediately.
+    ///
+    /// Note: this is scheduled to be removed when `future`s are natively supported.
+    would-block,
+    /// The operation is not valid in the socket's current state.
+    invalid-state,
+    /// A new socket resource could not be created because of a system limit.
+    new-socket-limit,
+    /// A bind operation failed because the provided address is not an address that the `network` can bind to.
+    address-not-bindable,
+    /// A bind operation failed because the provided address is already in use or because there are no ephemeral ports available.
+    address-in-use,
+    /// The remote address is not reachable
+    remote-unreachable,
+    /// The TCP connection was forcefully rejected
+    connection-refused,
+    /// The TCP connection was reset.
+    connection-reset,
+    /// A TCP connection was aborted.
+    connection-aborted,
+    /// The size of a datagram sent to a UDP socket exceeded the maximum
+    /// supported size.
+    datagram-too-large,
+    /// Name does not exist or has no suitable associated IP addresses.
+    name-unresolvable,
+    /// A temporary failure in name resolution occurred.
+    temporary-resolver-failure,
+    /// A permanent failure in name resolution occurred.
+    permanent-resolver-failure,
+  }
+
+  @since(version = 0.2.0)
+  enum ip-address-family {
+    /// Similar to `AF_INET` in POSIX.
+    ipv4,
+    /// Similar to `AF_INET6` in POSIX.
+    ipv6,
+  }
+
+  @since(version = 0.2.0)
+  type ipv4-address = tuple<u8, u8, u8, u8>;
+
+  @since(version = 0.2.0)
+  type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>;
+
+  @since(version = 0.2.0)
+  variant ip-address {
+    ipv4(ipv4-address),
+    ipv6(ipv6-address),
+  }
+
+  @since(version = 0.2.0)
+  record ipv4-socket-address {
+    /// sin_port
+    port: u16,
+    /// sin_addr
+    address: ipv4-address,
+  }
+
+  @since(version = 0.2.0)
+  record ipv6-socket-address {
+    /// sin6_port
+    port: u16,
+    /// sin6_flowinfo
+    flow-info: u32,
+    /// sin6_addr
+    address: ipv6-address,
+    /// sin6_scope_id
+    scope-id: u32,
+  }
+
+  @since(version = 0.2.0)
+  variant ip-socket-address {
+    ipv4(ipv4-socket-address),
+    ipv6(ipv6-socket-address),
+  }
+
+  /// Attempts to extract a network-related `error-code` from the stream
+  /// `error` provided.
+  ///
+  /// Stream operations which return `stream-error::last-operation-failed`
+  /// have a payload with more information about the operation that failed.
+  /// This payload can be passed through to this function to see if there's
+  /// network-related information about the error to return.
+  ///
+  /// Note that this function is fallible because not all stream-related
+  /// errors are network-related errors.
+  @unstable(feature = network-error-code)
+  network-error-code: func(err: borrow<error>) -> option<error-code>;
+}
+
+/// This interface provides a value-export of the default network handle..
+@since(version = 0.2.0)
+interface instance-network {
+  @since(version = 0.2.0)
+  use network.{network};
+
+  /// Get a handle to the default network.
+  @since(version = 0.2.0)
+  instance-network: func() -> network;
+}
+
+@since(version = 0.2.0)
+interface ip-name-lookup {
+  @since(version = 0.2.0)
+  use wasi:io/poll@0.2.6.{pollable};
+  @since(version = 0.2.0)
+  use network.{network, error-code, ip-address};
+
+  @since(version = 0.2.0)
+  resource resolve-address-stream {
+    /// Returns the next address from the resolver.
+    ///
+    /// This function should be called multiple times. On each call, it will
+    /// return the next address in connection order preference. If all
+    /// addresses have been exhausted, this function returns `none`.
+    ///
+    /// This function never returns IPv4-mapped IPv6 addresses.
+    ///
+    /// # Typical errors
+    /// - `name-unresolvable`:          Name does not exist or has no suitable associated IP addresses. (EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY)
+    /// - `temporary-resolver-failure`: A temporary failure in name resolution occurred. (EAI_AGAIN)
+    /// - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL)
+    /// - `would-block`:                A result is not available yet. (EWOULDBLOCK, EAGAIN)
+    @since(version = 0.2.0)
+    resolve-next-address: func() -> result<option<ip-address>, error-code>;
+    /// Create a `pollable` which will resolve once the stream is ready for I/O.
+    ///
+    /// Note: this function is here for WASI 0.2 only.
+    /// It's planned to be removed when `future` is natively supported in Preview3.
+    @since(version = 0.2.0)
+    subscribe: func() -> pollable;
+  }
+
+  /// Resolve an internet host name to a list of IP addresses.
+  ///
+  /// Unicode domain names are automatically converted to ASCII using IDNA encoding.
+  /// If the input is an IP address string, the address is parsed and returned
+  /// as-is without making any external requests.
+  ///
+  /// See the wasi-socket proposal README.md for a comparison with getaddrinfo.
+  ///
+  /// This function never blocks. It either immediately fails or immediately
+  /// returns successfully with a `resolve-address-stream` that can be used
+  /// to (asynchronously) fetch the results.
+  ///
+  /// # Typical errors
+  /// - `invalid-argument`: `name` is a syntactically invalid domain name or IP address.
+  ///
+  /// # References:
+  /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
+  /// - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html>
+  /// - <https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo>
+  /// - <https://man.freebsd.org/cgi/man.cgi?query=getaddrinfo&sektion=3>
+  @since(version = 0.2.0)
+  resolve-addresses: func(network: borrow<network>, name: string) -> result<resolve-address-stream, error-code>;
+}
+
+@since(version = 0.2.0)
+interface tcp {
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.6.{input-stream, output-stream};
+  @since(version = 0.2.0)
+  use wasi:io/poll@0.2.6.{pollable};
+  @since(version = 0.2.0)
+  use wasi:clocks/monotonic-clock@0.2.6.{duration};
+  @since(version = 0.2.0)
+  use network.{network, error-code, ip-socket-address, ip-address-family};
+
+  @since(version = 0.2.0)
+  enum shutdown-type {
+    /// Similar to `SHUT_RD` in POSIX.
+    receive,
+    /// Similar to `SHUT_WR` in POSIX.
+    send,
+    /// Similar to `SHUT_RDWR` in POSIX.
+    both,
+  }
+
+  /// A TCP socket resource.
+  ///
+  /// The socket can be in one of the following states:
+  /// - `unbound`
+  /// - `bind-in-progress`
+  /// - `bound` (See note below)
+  /// - `listen-in-progress`
+  /// - `listening`
+  /// - `connect-in-progress`
+  /// - `connected`
+  /// - `closed`
+  /// See <https://github.com/WebAssembly/wasi-sockets/blob/main/TcpSocketOperationalSemantics.md>
+  /// for more information.
+  ///
+  /// Note: Except where explicitly mentioned, whenever this documentation uses
+  /// the term "bound" without backticks it actually means: in the `bound` state *or higher*.
+  /// (i.e. `bound`, `listen-in-progress`, `listening`, `connect-in-progress` or `connected`)
+  ///
+  /// In addition to the general error codes documented on the
+  /// `network::error-code` type, TCP socket methods may always return
+  /// `error(invalid-state)` when in the `closed` state.
+  @since(version = 0.2.0)
+  resource tcp-socket {
+    /// Bind the socket to a specific network on the provided IP address and port.
+    ///
+    /// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which
+    /// network interface(s) to bind to.
+    /// If the TCP/UDP port is zero, the socket will be bound to a random free port.
+    ///
+    /// Bind can be attempted multiple times on the same socket, even with
+    /// different arguments on each iteration. But never concurrently and
+    /// only as long as the previous bind failed. Once a bind succeeds, the
+    /// binding can't be changed anymore.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:          The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows)
+    /// - `invalid-argument`:          `local-address` is not a unicast address. (EINVAL)
+    /// - `invalid-argument`:          `local-address` is an IPv4-mapped IPv6 address. (EINVAL)
+    /// - `invalid-state`:             The socket is already bound. (EINVAL)
+    /// - `address-in-use`:            No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
+    /// - `address-in-use`:            Address is already in use. (EADDRINUSE)
+    /// - `address-not-bindable`:      `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL)
+    /// - `not-in-progress`:           A `bind` operation is not in progress.
+    /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+    ///
+    /// # Implementors note
+    /// When binding to a non-zero port, this bind operation shouldn't be affected by the TIME_WAIT
+    /// state of a recently closed socket on the same local address. In practice this means that the SO_REUSEADDR
+    /// socket option should be set implicitly on all platforms, except on Windows where this is the default behavior
+    /// and SO_REUSEADDR performs something different entirely.
+    ///
+    /// Unlike in POSIX, in WASI the bind operation is async. This enables
+    /// interactive WASI hosts to inject permission prompts. Runtimes that
+    /// don't want to make use of this ability can simply call the native
+    /// `bind` as part of either `start-bind` or `finish-bind`.
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
+    /// - <https://man7.org/linux/man-pages/man2/bind.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
+    @since(version = 0.2.0)
+    start-bind: func(network: borrow<network>, local-address: ip-socket-address) -> result<_, error-code>;
+    @since(version = 0.2.0)
+    finish-bind: func() -> result<_, error-code>;
+    /// Connect to a remote endpoint.
+    ///
+    /// On success:
+    /// - the socket is transitioned into the `connected` state.
+    /// - a pair of streams is returned that can be used to read & write to the connection
+    ///
+    /// After a failed connection attempt, the socket will be in the `closed`
+    /// state and the only valid action left is to `drop` the socket. A single
+    /// socket can not be used to connect more than once.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:          The `remote-address` has the wrong address family. (EAFNOSUPPORT)
+    /// - `invalid-argument`:          `remote-address` is not a unicast address. (EINVAL, ENETUNREACH on Linux, EAFNOSUPPORT on MacOS)
+    /// - `invalid-argument`:          `remote-address` is an IPv4-mapped IPv6 address. (EINVAL, EADDRNOTAVAIL on Illumos)
+    /// - `invalid-argument`:          The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EADDRNOTAVAIL on Windows)
+    /// - `invalid-argument`:          The port in `remote-address` is set to 0. (EADDRNOTAVAIL on Windows)
+    /// - `invalid-argument`:          The socket is already attached to a different network. The `network` passed to `connect` must be identical to the one passed to `bind`.
+    /// - `invalid-state`:             The socket is already in the `connected` state. (EISCONN)
+    /// - `invalid-state`:             The socket is already in the `listening` state. (EOPNOTSUPP, EINVAL on Windows)
+    /// - `timeout`:                   Connection timed out. (ETIMEDOUT)
+    /// - `connection-refused`:        The connection was forcefully rejected. (ECONNREFUSED)
+    /// - `connection-reset`:          The connection was reset. (ECONNRESET)
+    /// - `connection-aborted`:        The connection was aborted. (ECONNABORTED)
+    /// - `remote-unreachable`:        The remote address is not reachable. (EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+    /// - `address-in-use`:            Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
+    /// - `not-in-progress`:           A connect operation is not in progress.
+    /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+    ///
+    /// # Implementors note
+    /// The POSIX equivalent of `start-connect` is the regular `connect` syscall.
+    /// Because all WASI sockets are non-blocking this is expected to return
+    /// EINPROGRESS, which should be translated to `ok()` in WASI.
+    ///
+    /// The POSIX equivalent of `finish-connect` is a `poll` for event `POLLOUT`
+    /// with a timeout of 0 on the socket descriptor. Followed by a check for
+    /// the `SO_ERROR` socket option, in case the poll signaled readiness.
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
+    /// - <https://man7.org/linux/man-pages/man2/connect.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
+    /// - <https://man.freebsd.org/cgi/man.cgi?connect>
+    @since(version = 0.2.0)
+    start-connect: func(network: borrow<network>, remote-address: ip-socket-address) -> result<_, error-code>;
+    @since(version = 0.2.0)
+    finish-connect: func() -> result<tuple<input-stream, output-stream>, error-code>;
+    /// Start listening for new connections.
+    ///
+    /// Transitions the socket into the `listening` state.
+    ///
+    /// Unlike POSIX, the socket must already be explicitly bound.
+    ///
+    /// # Typical errors
+    /// - `invalid-state`:             The socket is not bound to any local address. (EDESTADDRREQ)
+    /// - `invalid-state`:             The socket is already in the `connected` state. (EISCONN, EINVAL on BSD)
+    /// - `invalid-state`:             The socket is already in the `listening` state.
+    /// - `address-in-use`:            Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE)
+    /// - `not-in-progress`:           A listen operation is not in progress.
+    /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+    ///
+    /// # Implementors note
+    /// Unlike in POSIX, in WASI the listen operation is async. This enables
+    /// interactive WASI hosts to inject permission prompts. Runtimes that
+    /// don't want to make use of this ability can simply call the native
+    /// `listen` as part of either `start-listen` or `finish-listen`.
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/listen.html>
+    /// - <https://man7.org/linux/man-pages/man2/listen.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-listen>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=listen&sektion=2>
+    @since(version = 0.2.0)
+    start-listen: func() -> result<_, error-code>;
+    @since(version = 0.2.0)
+    finish-listen: func() -> result<_, error-code>;
+    /// Accept a new client socket.
+    ///
+    /// The returned socket is bound and in the `connected` state. The following properties are inherited from the listener socket:
+    /// - `address-family`
+    /// - `keep-alive-enabled`
+    /// - `keep-alive-idle-time`
+    /// - `keep-alive-interval`
+    /// - `keep-alive-count`
+    /// - `hop-limit`
+    /// - `receive-buffer-size`
+    /// - `send-buffer-size`
+    ///
+    /// On success, this function returns the newly accepted client socket along with
+    /// a pair of streams that can be used to read & write to the connection.
+    ///
+    /// # Typical errors
+    /// - `invalid-state`:      Socket is not in the `listening` state. (EINVAL)
+    /// - `would-block`:        No pending connections at the moment. (EWOULDBLOCK, EAGAIN)
+    /// - `connection-aborted`: An incoming connection was pending, but was terminated by the client before this listener could accept it. (ECONNABORTED)
+    /// - `new-socket-limit`:   The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/accept.html>
+    /// - <https://man7.org/linux/man-pages/man2/accept.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-accept>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=accept&sektion=2>
+    @since(version = 0.2.0)
+    accept: func() -> result<tuple<tcp-socket, input-stream, output-stream>, error-code>;
+    /// Get the bound local address.
+    ///
+    /// POSIX mentions:
+    /// > If the socket has not been bound to a local name, the value
+    /// > stored in the object pointed to by `address` is unspecified.
+    ///
+    /// WASI is stricter and requires `local-address` to return `invalid-state` when the socket hasn't been bound yet.
+    ///
+    /// # Typical errors
+    /// - `invalid-state`: The socket is not bound to any local address.
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
+    /// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
+    /// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
+    @since(version = 0.2.0)
+    local-address: func() -> result<ip-socket-address, error-code>;
+    /// Get the remote address.
+    ///
+    /// # Typical errors
+    /// - `invalid-state`: The socket is not connected to a remote address. (ENOTCONN)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
+    /// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
+    @since(version = 0.2.0)
+    remote-address: func() -> result<ip-socket-address, error-code>;
+    /// Whether the socket is in the `listening` state.
+    ///
+    /// Equivalent to the SO_ACCEPTCONN socket option.
+    @since(version = 0.2.0)
+    is-listening: func() -> bool;
+    /// Whether this is a IPv4 or IPv6 socket.
+    ///
+    /// Equivalent to the SO_DOMAIN socket option.
+    @since(version = 0.2.0)
+    address-family: func() -> ip-address-family;
+    /// Hints the desired listen queue size. Implementations are free to ignore this.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+    ///
+    /// # Typical errors
+    /// - `not-supported`:        (set) The platform does not support changing the backlog size after the initial listen.
+    /// - `invalid-argument`:     (set) The provided value was 0.
+    /// - `invalid-state`:        (set) The socket is in the `connect-in-progress` or `connected` state.
+    @since(version = 0.2.0)
+    set-listen-backlog-size: func(value: u64) -> result<_, error-code>;
+    /// Enables or disables keepalive.
+    ///
+    /// The keepalive behavior can be adjusted using:
+    /// - `keep-alive-idle-time`
+    /// - `keep-alive-interval`
+    /// - `keep-alive-count`
+    /// These properties can be configured while `keep-alive-enabled` is false, but only come into effect when `keep-alive-enabled` is true.
+    ///
+    /// Equivalent to the SO_KEEPALIVE socket option.
+    @since(version = 0.2.0)
+    keep-alive-enabled: func() -> result<bool, error-code>;
+    @since(version = 0.2.0)
+    set-keep-alive-enabled: func(value: bool) -> result<_, error-code>;
+    /// Amount of time the connection has to be idle before TCP starts sending keepalive packets.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+    /// I.e. after setting a value, reading the same setting back may return a different value.
+    ///
+    /// Equivalent to the TCP_KEEPIDLE socket option. (TCP_KEEPALIVE on MacOS)
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:     (set) The provided value was 0.
+    @since(version = 0.2.0)
+    keep-alive-idle-time: func() -> result<duration, error-code>;
+    @since(version = 0.2.0)
+    set-keep-alive-idle-time: func(value: duration) -> result<_, error-code>;
+    /// The time between keepalive packets.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+    /// I.e. after setting a value, reading the same setting back may return a different value.
+    ///
+    /// Equivalent to the TCP_KEEPINTVL socket option.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:     (set) The provided value was 0.
+    @since(version = 0.2.0)
+    keep-alive-interval: func() -> result<duration, error-code>;
+    @since(version = 0.2.0)
+    set-keep-alive-interval: func(value: duration) -> result<_, error-code>;
+    /// The maximum amount of keepalive packets TCP should send before aborting the connection.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+    /// I.e. after setting a value, reading the same setting back may return a different value.
+    ///
+    /// Equivalent to the TCP_KEEPCNT socket option.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:     (set) The provided value was 0.
+    @since(version = 0.2.0)
+    keep-alive-count: func() -> result<u32, error-code>;
+    @since(version = 0.2.0)
+    set-keep-alive-count: func(value: u32) -> result<_, error-code>;
+    /// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:     (set) The TTL value must be 1 or higher.
+    @since(version = 0.2.0)
+    hop-limit: func() -> result<u8, error-code>;
+    @since(version = 0.2.0)
+    set-hop-limit: func(value: u8) -> result<_, error-code>;
+    /// The kernel buffer space reserved for sends/receives on this socket.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+    /// I.e. after setting a value, reading the same setting back may return a different value.
+    ///
+    /// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:     (set) The provided value was 0.
+    @since(version = 0.2.0)
+    receive-buffer-size: func() -> result<u64, error-code>;
+    @since(version = 0.2.0)
+    set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
+    @since(version = 0.2.0)
+    send-buffer-size: func() -> result<u64, error-code>;
+    @since(version = 0.2.0)
+    set-send-buffer-size: func(value: u64) -> result<_, error-code>;
+    /// Create a `pollable` which can be used to poll for, or block on,
+    /// completion of any of the asynchronous operations of this socket.
+    ///
+    /// When `finish-bind`, `finish-listen`, `finish-connect` or `accept`
+    /// return `error(would-block)`, this pollable can be used to wait for
+    /// their success or failure, after which the method can be retried.
+    ///
+    /// The pollable is not limited to the async operation that happens to be
+    /// in progress at the time of calling `subscribe` (if any). Theoretically,
+    /// `subscribe` only has to be called once per socket and can then be
+    /// (re)used for the remainder of the socket's lifetime.
+    ///
+    /// See <https://github.com/WebAssembly/wasi-sockets/blob/main/TcpSocketOperationalSemantics.md#pollable-readiness>
+    /// for more information.
+    ///
+    /// Note: this function is here for WASI 0.2 only.
+    /// It's planned to be removed when `future` is natively supported in Preview3.
+    @since(version = 0.2.0)
+    subscribe: func() -> pollable;
+    /// Initiate a graceful shutdown.
+    ///
+    /// - `receive`: The socket is not expecting to receive any data from
+    ///   the peer. The `input-stream` associated with this socket will be
+    ///   closed. Any data still in the receive queue at time of calling
+    ///   this method will be discarded.
+    /// - `send`: The socket has no more data to send to the peer. The `output-stream`
+    ///   associated with this socket will be closed and a FIN packet will be sent.
+    /// - `both`: Same effect as `receive` & `send` combined.
+    ///
+    /// This function is idempotent; shutting down a direction more than once
+    /// has no effect and returns `ok`.
+    ///
+    /// The shutdown function does not close (drop) the socket.
+    ///
+    /// # Typical errors
+    /// - `invalid-state`: The socket is not in the `connected` state. (ENOTCONN)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/shutdown.html>
+    /// - <https://man7.org/linux/man-pages/man2/shutdown.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-shutdown>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=shutdown&sektion=2>
+    @since(version = 0.2.0)
+    shutdown: func(shutdown-type: shutdown-type) -> result<_, error-code>;
+  }
+}
+
+@since(version = 0.2.0)
+interface tcp-create-socket {
+  @since(version = 0.2.0)
+  use network.{network, error-code, ip-address-family};
+  @since(version = 0.2.0)
+  use tcp.{tcp-socket};
+
+  /// Create a new TCP socket.
+  ///
+  /// Similar to `socket(AF_INET or AF_INET6, SOCK_STREAM, IPPROTO_TCP)` in POSIX.
+  /// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.
+  ///
+  /// This function does not require a network capability handle. This is considered to be safe because
+  /// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind`/`connect`
+  /// is called, the socket is effectively an in-memory configuration object, unable to communicate with the outside world.
+  ///
+  /// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
+  ///
+  /// # Typical errors
+  /// - `not-supported`:     The specified `address-family` is not supported. (EAFNOSUPPORT)
+  /// - `new-socket-limit`:  The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
+  ///
+  /// # References
+  /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
+  /// - <https://man7.org/linux/man-pages/man2/socket.2.html>
+  /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
+  /// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
+  @since(version = 0.2.0)
+  create-tcp-socket: func(address-family: ip-address-family) -> result<tcp-socket, error-code>;
+}
+
+@since(version = 0.2.0)
+interface udp {
+  @since(version = 0.2.0)
+  use wasi:io/poll@0.2.6.{pollable};
+  @since(version = 0.2.0)
+  use network.{network, error-code, ip-socket-address, ip-address-family};
+
+  /// A received datagram.
+  @since(version = 0.2.0)
+  record incoming-datagram {
+    /// The payload.
+    ///
+    /// Theoretical max size: ~64 KiB. In practice, typically less than 1500 bytes.
+    data: list<u8>,
+    /// The source address.
+    ///
+    /// This field is guaranteed to match the remote address the stream was initialized with, if any.
+    ///
+    /// Equivalent to the `src_addr` out parameter of `recvfrom`.
+    remote-address: ip-socket-address,
+  }
+
+  /// A datagram to be sent out.
+  @since(version = 0.2.0)
+  record outgoing-datagram {
+    /// The payload.
+    data: list<u8>,
+    /// The destination address.
+    ///
+    /// The requirements on this field depend on how the stream was initialized:
+    /// - with a remote address: this field must be None or match the stream's remote address exactly.
+    /// - without a remote address: this field is required.
+    ///
+    /// If this value is None, the send operation is equivalent to `send` in POSIX. Otherwise it is equivalent to `sendto`.
+    remote-address: option<ip-socket-address>,
+  }
+
+  /// A UDP socket handle.
+  @since(version = 0.2.0)
+  resource udp-socket {
+    /// Bind the socket to a specific network on the provided IP address and port.
+    ///
+    /// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which
+    /// network interface(s) to bind to.
+    /// If the port is zero, the socket will be bound to a random free port.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:          The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows)
+    /// - `invalid-state`:             The socket is already bound. (EINVAL)
+    /// - `address-in-use`:            No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
+    /// - `address-in-use`:            Address is already in use. (EADDRINUSE)
+    /// - `address-not-bindable`:      `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL)
+    /// - `not-in-progress`:           A `bind` operation is not in progress.
+    /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+    ///
+    /// # Implementors note
+    /// Unlike in POSIX, in WASI the bind operation is async. This enables
+    /// interactive WASI hosts to inject permission prompts. Runtimes that
+    /// don't want to make use of this ability can simply call the native
+    /// `bind` as part of either `start-bind` or `finish-bind`.
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
+    /// - <https://man7.org/linux/man-pages/man2/bind.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
+    @since(version = 0.2.0)
+    start-bind: func(network: borrow<network>, local-address: ip-socket-address) -> result<_, error-code>;
+    @since(version = 0.2.0)
+    finish-bind: func() -> result<_, error-code>;
+    /// Set up inbound & outbound communication channels, optionally to a specific peer.
+    ///
+    /// This function only changes the local socket configuration and does not generate any network traffic.
+    /// On success, the `remote-address` of the socket is updated. The `local-address` may be updated as well,
+    /// based on the best network path to `remote-address`.
+    ///
+    /// When a `remote-address` is provided, the returned streams are limited to communicating with that specific peer:
+    /// - `send` can only be used to send to this destination.
+    /// - `receive` will only return datagrams sent from the provided `remote-address`.
+    ///
+    /// This method may be called multiple times on the same socket to change its association, but
+    /// only the most recently returned pair of streams will be operational. Implementations may trap if
+    /// the streams returned by a previous invocation haven't been dropped yet before calling `stream` again.
+    ///
+    /// The POSIX equivalent in pseudo-code is:
+    /// ```text
+    /// if (was previously connected) {
+    /// 	connect(s, AF_UNSPEC)
+    /// }
+    /// if (remote_address is Some) {
+    /// 	connect(s, remote_address)
+    /// }
+    /// ```
+    ///
+    /// Unlike in POSIX, the socket must already be explicitly bound.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:          The `remote-address` has the wrong address family. (EAFNOSUPPORT)
+    /// - `invalid-argument`:          The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
+    /// - `invalid-argument`:          The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
+    /// - `invalid-state`:             The socket is not bound.
+    /// - `address-in-use`:            Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
+    /// - `remote-unreachable`:        The remote address is not reachable. (ECONNRESET, ENETRESET, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+    /// - `connection-refused`:        The connection was refused. (ECONNREFUSED)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
+    /// - <https://man7.org/linux/man-pages/man2/connect.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
+    /// - <https://man.freebsd.org/cgi/man.cgi?connect>
+    @since(version = 0.2.0)
+    %stream: func(remote-address: option<ip-socket-address>) -> result<tuple<incoming-datagram-stream, outgoing-datagram-stream>, error-code>;
+    /// Get the current bound address.
+    ///
+    /// POSIX mentions:
+    /// > If the socket has not been bound to a local name, the value
+    /// > stored in the object pointed to by `address` is unspecified.
+    ///
+    /// WASI is stricter and requires `local-address` to return `invalid-state` when the socket hasn't been bound yet.
+    ///
+    /// # Typical errors
+    /// - `invalid-state`: The socket is not bound to any local address.
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
+    /// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
+    /// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
+    @since(version = 0.2.0)
+    local-address: func() -> result<ip-socket-address, error-code>;
+    /// Get the address the socket is currently streaming to.
+    ///
+    /// # Typical errors
+    /// - `invalid-state`: The socket is not streaming to a specific remote address. (ENOTCONN)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
+    /// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
+    @since(version = 0.2.0)
+    remote-address: func() -> result<ip-socket-address, error-code>;
+    /// Whether this is a IPv4 or IPv6 socket.
+    ///
+    /// Equivalent to the SO_DOMAIN socket option.
+    @since(version = 0.2.0)
+    address-family: func() -> ip-address-family;
+    /// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:     (set) The TTL value must be 1 or higher.
+    @since(version = 0.2.0)
+    unicast-hop-limit: func() -> result<u8, error-code>;
+    @since(version = 0.2.0)
+    set-unicast-hop-limit: func(value: u8) -> result<_, error-code>;
+    /// The kernel buffer space reserved for sends/receives on this socket.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+    /// I.e. after setting a value, reading the same setting back may return a different value.
+    ///
+    /// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:     (set) The provided value was 0.
+    @since(version = 0.2.0)
+    receive-buffer-size: func() -> result<u64, error-code>;
+    @since(version = 0.2.0)
+    set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
+    @since(version = 0.2.0)
+    send-buffer-size: func() -> result<u64, error-code>;
+    @since(version = 0.2.0)
+    set-send-buffer-size: func(value: u64) -> result<_, error-code>;
+    /// Create a `pollable` which will resolve once the socket is ready for I/O.
+    ///
+    /// Note: this function is here for WASI 0.2 only.
+    /// It's planned to be removed when `future` is natively supported in Preview3.
+    @since(version = 0.2.0)
+    subscribe: func() -> pollable;
+  }
+
+  @since(version = 0.2.0)
+  resource incoming-datagram-stream {
+    /// Receive messages on the socket.
+    ///
+    /// This function attempts to receive up to `max-results` datagrams on the socket without blocking.
+    /// The returned list may contain fewer elements than requested, but never more.
+    ///
+    /// This function returns successfully with an empty list when either:
+    /// - `max-results` is 0, or:
+    /// - `max-results` is greater than 0, but no results are immediately available.
+    /// This function never returns `error(would-block)`.
+    ///
+    /// # Typical errors
+    /// - `remote-unreachable`: The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+    /// - `connection-refused`: The connection was refused. (ECONNREFUSED)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvfrom.html>
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvmsg.html>
+    /// - <https://man7.org/linux/man-pages/man2/recv.2.html>
+    /// - <https://man7.org/linux/man-pages/man2/recvmmsg.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recv>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recvfrom>
+    /// - <https://learn.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms741687(v=vs.85)>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=recv&sektion=2>
+    @since(version = 0.2.0)
+    receive: func(max-results: u64) -> result<list<incoming-datagram>, error-code>;
+    /// Create a `pollable` which will resolve once the stream is ready to receive again.
+    ///
+    /// Note: this function is here for WASI 0.2 only.
+    /// It's planned to be removed when `future` is natively supported in Preview3.
+    @since(version = 0.2.0)
+    subscribe: func() -> pollable;
+  }
+
+  @since(version = 0.2.0)
+  resource outgoing-datagram-stream {
+    /// Check readiness for sending. This function never blocks.
+    ///
+    /// Returns the number of datagrams permitted for the next call to `send`,
+    /// or an error. Calling `send` with more datagrams than this function has
+    /// permitted will trap.
+    ///
+    /// When this function returns ok(0), the `subscribe` pollable will
+    /// become ready when this function will report at least ok(1), or an
+    /// error.
+    ///
+    /// Never returns `would-block`.
+    check-send: func() -> result<u64, error-code>;
+    /// Send messages on the socket.
+    ///
+    /// This function attempts to send all provided `datagrams` on the socket without blocking and
+    /// returns how many messages were actually sent (or queued for sending). This function never
+    /// returns `error(would-block)`. If none of the datagrams were able to be sent, `ok(0)` is returned.
+    ///
+    /// This function semantically behaves the same as iterating the `datagrams` list and sequentially
+    /// sending each individual datagram until either the end of the list has been reached or the first error occurred.
+    /// If at least one datagram has been sent successfully, this function never returns an error.
+    ///
+    /// If the input list is empty, the function returns `ok(0)`.
+    ///
+    /// Each call to `send` must be permitted by a preceding `check-send`. Implementations must trap if
+    /// either `check-send` was not called or `datagrams` contains more items than `check-send` permitted.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:        The `remote-address` has the wrong address family. (EAFNOSUPPORT)
+    /// - `invalid-argument`:        The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
+    /// - `invalid-argument`:        The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
+    /// - `invalid-argument`:        The socket is in "connected" mode and `remote-address` is `some` value that does not match the address passed to `stream`. (EISCONN)
+    /// - `invalid-argument`:        The socket is not "connected" and no value for `remote-address` was provided. (EDESTADDRREQ)
+    /// - `remote-unreachable`:      The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+    /// - `connection-refused`:      The connection was refused. (ECONNREFUSED)
+    /// - `datagram-too-large`:      The datagram is too large. (EMSGSIZE)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendto.html>
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendmsg.html>
+    /// - <https://man7.org/linux/man-pages/man2/send.2.html>
+    /// - <https://man7.org/linux/man-pages/man2/sendmmsg.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-send>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-sendto>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasendmsg>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=send&sektion=2>
+    @since(version = 0.2.0)
+    send: func(datagrams: list<outgoing-datagram>) -> result<u64, error-code>;
+    /// Create a `pollable` which will resolve once the stream is ready to send again.
+    ///
+    /// Note: this function is here for WASI 0.2 only.
+    /// It's planned to be removed when `future` is natively supported in Preview3.
+    @since(version = 0.2.0)
+    subscribe: func() -> pollable;
+  }
+}
+
+@since(version = 0.2.0)
+interface udp-create-socket {
+  @since(version = 0.2.0)
+  use network.{network, error-code, ip-address-family};
+  @since(version = 0.2.0)
+  use udp.{udp-socket};
+
+  /// Create a new UDP socket.
+  ///
+  /// Similar to `socket(AF_INET or AF_INET6, SOCK_DGRAM, IPPROTO_UDP)` in POSIX.
+  /// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.
+  ///
+  /// This function does not require a network capability handle. This is considered to be safe because
+  /// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind` is called,
+  /// the socket is effectively an in-memory configuration object, unable to communicate with the outside world.
+  ///
+  /// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
+  ///
+  /// # Typical errors
+  /// - `not-supported`:     The specified `address-family` is not supported. (EAFNOSUPPORT)
+  /// - `new-socket-limit`:  The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
+  ///
+  /// # References:
+  /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
+  /// - <https://man7.org/linux/man-pages/man2/socket.2.html>
+  /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
+  /// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
+  @since(version = 0.2.0)
+  create-udp-socket: func(address-family: ip-address-family) -> result<udp-socket, error-code>;
+}
+
+@since(version = 0.2.0)
+world imports {
+  @since(version = 0.2.0)
+  import wasi:io/error@0.2.6;
+  @since(version = 0.2.0)
+  import network;
+  @since(version = 0.2.0)
+  import instance-network;
+  @since(version = 0.2.0)
+  import wasi:io/poll@0.2.6;
+  @since(version = 0.2.0)
+  import udp;
+  @since(version = 0.2.0)
+  import udp-create-socket;
+  @since(version = 0.2.0)
+  import wasi:io/streams@0.2.6;
+  @since(version = 0.2.0)
+  import wasi:clocks/monotonic-clock@0.2.6;
+  @since(version = 0.2.0)
+  import tcp;
+  @since(version = 0.2.0)
+  import tcp-create-socket;
+  @since(version = 0.2.0)
+  import ip-name-lookup;
+}
diff --git a/sdks/go/golem/wit/deps/sockets/sockets.wit b/sdks/go/golem/wit/deps/sockets/sockets.wit
new file mode 100644
index 0000000000..0dd27a4fc4
--- /dev/null
+++ b/sdks/go/golem/wit/deps/sockets/sockets.wit
@@ -0,0 +1,839 @@
+package wasi:sockets@0.3.0;
+
+@since(version = 0.3.0)
+interface types {
+  @since(version = 0.3.0)
+  use wasi:clocks/types@0.3.0.{duration};
+
+  /// Error codes.
+  ///
+  /// In theory, every API can return any error code.
+  /// In practice, API's typically only return the errors documented per API
+  /// combined with a couple of errors that are always possible:
+  /// - `other`
+  /// - `access-denied`
+  /// - `not-supported`
+  /// - `out-of-memory`
+  ///
+  /// See each individual API for what the POSIX equivalents are. They sometimes differ per API.
+  @since(version = 0.3.0)
+  variant error-code {
+    /// Access denied.
+    ///
+    /// POSIX equivalent: EACCES, EPERM
+    access-denied,
+    /// The operation is not supported.
+    ///
+    /// POSIX equivalent: EOPNOTSUPP, ENOPROTOOPT, EPFNOSUPPORT, EPROTONOSUPPORT, ESOCKTNOSUPPORT
+    not-supported,
+    /// One of the arguments is invalid.
+    ///
+    /// POSIX equivalent: EINVAL, EDESTADDRREQ, EAFNOSUPPORT
+    invalid-argument,
+    /// Not enough memory to complete the operation.
+    ///
+    /// POSIX equivalent: ENOMEM, ENOBUFS
+    out-of-memory,
+    /// The operation timed out before it could finish completely.
+    ///
+    /// POSIX equivalent: ETIMEDOUT
+    timeout,
+    /// The operation is not valid in the socket's current state.
+    invalid-state,
+    /// The local address is not available.
+    ///
+    /// POSIX equivalent: EADDRNOTAVAIL
+    address-not-bindable,
+    /// A bind operation failed because the provided address is already in
+    /// use or because there are no ephemeral ports available.
+    ///
+    /// POSIX equivalent: EADDRINUSE
+    address-in-use,
+    /// The remote address is not reachable.
+    ///
+    /// POSIX equivalent: EHOSTUNREACH, EHOSTDOWN, ENETDOWN, ENETUNREACH, ENONET
+    remote-unreachable,
+    /// The connection was forcefully rejected.
+    ///
+    /// POSIX equivalent: ECONNREFUSED
+    connection-refused,
+    /// A write failed because the connection was broken.
+    ///
+    /// POSIX equivalent: EPIPE
+    connection-broken,
+    /// The connection was reset.
+    ///
+    /// POSIX equivalent: ECONNRESET
+    connection-reset,
+    /// The connection was aborted.
+    ///
+    /// POSIX equivalent: ECONNABORTED
+    connection-aborted,
+    /// The size of a datagram sent to a UDP socket exceeded the maximum
+    /// supported size.
+    ///
+    /// POSIX equivalent: EMSGSIZE
+    datagram-too-large,
+    /// A catch-all for errors not captured by the existing variants.
+    /// Implementations can use this to extend the error type without
+    /// breaking existing code.
+    other(option<string>),
+  }
+
+  @since(version = 0.3.0)
+  enum ip-address-family {
+    /// Similar to `AF_INET` in POSIX.
+    ipv4,
+    /// Similar to `AF_INET6` in POSIX.
+    ipv6,
+  }
+
+  @since(version = 0.3.0)
+  type ipv4-address = tuple<u8, u8, u8, u8>;
+
+  @since(version = 0.3.0)
+  type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>;
+
+  @since(version = 0.3.0)
+  variant ip-address {
+    ipv4(ipv4-address),
+    ipv6(ipv6-address),
+  }
+
+  @since(version = 0.3.0)
+  record ipv4-socket-address {
+    /// sin_port
+    port: u16,
+    /// sin_addr
+    address: ipv4-address,
+  }
+
+  @since(version = 0.3.0)
+  record ipv6-socket-address {
+    /// sin6_port
+    port: u16,
+    /// sin6_flowinfo
+    flow-info: u32,
+    /// sin6_addr
+    address: ipv6-address,
+    /// sin6_scope_id
+    scope-id: u32,
+  }
+
+  @since(version = 0.3.0)
+  variant ip-socket-address {
+    ipv4(ipv4-socket-address),
+    ipv6(ipv6-socket-address),
+  }
+
+  /// A TCP socket resource.
+  ///
+  /// The socket can be in one of the following states:
+  /// - `unbound`
+  /// - `bound` (See note below)
+  /// - `listening`
+  /// - `connecting`
+  /// - `connected`
+  /// - `closed`
+  /// See <https://github.com/WebAssembly/WASI/blob/main/proposals/sockets/TcpSocketOperationalSemantics-0.3.0.md>
+  /// for more information.
+  ///
+  /// Note: Except where explicitly mentioned, whenever this documentation uses
+  /// the term "bound" without backticks it actually means: in the `bound` state *or higher*.
+  /// (i.e. `bound`, `listening`, `connecting` or `connected`)
+  ///
+  /// WASI uses shared ownership semantics: the `tcp-socket` handle and all
+  /// derived `stream` and `future` values reference a single underlying OS
+  /// socket:
+  /// - Send/receive streams remain functional after the original `tcp-socket`
+  ///   handle is dropped.
+  /// - The stream returned by `listen` behaves similarly.
+  /// - Client sockets returned by `tcp-socket::listen` are independent and do
+  ///   not keep the listening socket alive.
+  ///
+  /// The OS socket is closed only after the last handle is dropped. This
+  /// model has observable effects; for example, it affects when the local
+  /// port binding is released.
+  ///
+  /// In addition to the general error codes documented on the
+  /// `types::error-code` type, TCP socket methods may always return
+  /// `error(invalid-state)` when in the `closed` state.
+  @since(version = 0.3.0)
+  resource tcp-socket {
+    /// Create a new TCP socket.
+    ///
+    /// Similar to `socket(AF_INET or AF_INET6, SOCK_STREAM, IPPROTO_TCP)`
+    /// in POSIX. On IPv6 sockets, IPV6_V6ONLY is enabled by default and
+    /// can't be configured otherwise.
+    ///
+    /// Unlike POSIX, WASI sockets have no notion of a socket-level
+    /// `O_NONBLOCK` flag. Instead they fully rely on the Component Model's
+    /// async support.
+    ///
+    /// # Typical errors
+    /// - `not-supported`: The `address-family` is not supported. (EAFNOSUPPORT)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
+    /// - <https://man7.org/linux/man-pages/man2/socket.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
+    @since(version = 0.3.0)
+    create: static func(address-family: ip-address-family) -> result<tcp-socket, error-code>;
+    /// Bind the socket to the provided IP address and port.
+    ///
+    /// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is
+    /// left to the implementation to decide which network interface(s) to
+    /// bind to. If the TCP/UDP port is zero, the socket will be bound to a
+    /// random free port.
+    ///
+    /// Bind can be attempted multiple times on the same socket, even with
+    /// different arguments on each iteration. But never concurrently and
+    /// only as long as the previous bind failed. Once a bind succeeds, the
+    /// binding can't be changed anymore.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:          The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows)
+    /// - `invalid-argument`:          `local-address` is not a unicast address. (EINVAL)
+    /// - `invalid-argument`:          `local-address` is an IPv4-mapped IPv6 address. (EINVAL)
+    /// - `invalid-state`:             The socket is already bound. (EINVAL)
+    /// - `address-in-use`:            No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
+    /// - `address-in-use`:            Address is already in use. (EADDRINUSE)
+    /// - `address-not-bindable`:      `local-address` is not an address that can be bound to. (EADDRNOTAVAIL)
+    ///
+    /// # Implementors note
+    /// The bind operation shouldn't be affected by the TIME_WAIT state of a
+    /// recently closed socket on the same local address. In practice this
+    /// means that the SO_REUSEADDR socket option should be set implicitly
+    /// on all platforms, except on Windows where this is the default
+    /// behavior and SO_REUSEADDR performs something different.
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
+    /// - <https://man7.org/linux/man-pages/man2/bind.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
+    @since(version = 0.3.0)
+    bind: func(local-address: ip-socket-address) -> result<_, error-code>;
+    /// Connect to a remote endpoint.
+    ///
+    /// On success, the socket is transitioned into the `connected` state
+    /// and the `remote-address` of the socket is updated.
+    /// The `local-address` may be updated as well, based on the best network
+    /// path to `remote-address`. If the socket was not already explicitly
+    /// bound, this function will implicitly bind the socket to a random
+    /// free port.
+    ///
+    /// After a failed connection attempt, the socket will be in the `closed`
+    /// state and the only valid action left is to `drop` the socket. A single
+    /// socket can not be used to connect more than once.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:          The `remote-address` has the wrong address family. (EAFNOSUPPORT)
+    /// - `invalid-argument`:          `remote-address` is not a unicast address. (EINVAL, ENETUNREACH on Linux, EAFNOSUPPORT on MacOS)
+    /// - `invalid-argument`:          `remote-address` is an IPv4-mapped IPv6 address. (EINVAL, EADDRNOTAVAIL on Illumos)
+    /// - `invalid-argument`:          The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EADDRNOTAVAIL on Windows)
+    /// - `invalid-argument`:          The port in `remote-address` is set to 0. (EADDRNOTAVAIL on Windows)
+    /// - `invalid-state`:             The socket is already in the `connecting` state. (EALREADY)
+    /// - `invalid-state`:             The socket is already in the `connected` state. (EISCONN)
+    /// - `invalid-state`:             The socket is already in the `listening` state. (EOPNOTSUPP, EINVAL on Windows)
+    /// - `timeout`:                   Connection timed out. (ETIMEDOUT)
+    /// - `connection-refused`:        The connection was forcefully rejected. (ECONNREFUSED)
+    /// - `connection-reset`:          The connection was reset. (ECONNRESET)
+    /// - `connection-aborted`:        The connection was aborted. (ECONNABORTED)
+    /// - `remote-unreachable`:        The remote address is not reachable. (EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+    /// - `address-in-use`:            Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
+    /// - <https://man7.org/linux/man-pages/man2/connect.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
+    /// - <https://man.freebsd.org/cgi/man.cgi?connect>
+    @since(version = 0.3.0)
+    connect: async func(remote-address: ip-socket-address) -> result<_, error-code>;
+    /// Start listening and return a stream of new inbound connections.
+    ///
+    /// Transitions the socket into the `listening` state. This can be called
+    /// at most once per socket.
+    ///
+    /// If the socket is not already explicitly bound, this function will
+    /// implicitly bind the socket to a random free port.
+    ///
+    /// Normally, the returned sockets are bound, in the `connected` state
+    /// and immediately ready for I/O. Though, depending on exact timing and
+    /// circumstances, a newly accepted connection may already be `closed`
+    /// by the time the server attempts to perform its first I/O on it. This
+    /// is true regardless of whether the WASI implementation uses
+    /// "synthesized" sockets or not (see Implementors Notes below).
+    ///
+    /// The following properties are inherited from the listener socket:
+    /// - `address-family`
+    /// - `keep-alive-enabled`
+    /// - `keep-alive-idle-time`
+    /// - `keep-alive-interval`
+    /// - `keep-alive-count`
+    /// - `hop-limit`
+    /// - `receive-buffer-size`
+    /// - `send-buffer-size`
+    ///
+    /// # Typical errors
+    /// - `invalid-state`:             The socket is already in the `connected` state. (EISCONN, EINVAL on BSD)
+    /// - `invalid-state`:             The socket is already in the `listening` state.
+    /// - `address-in-use`:            Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE)
+    ///
+    /// # Implementors note
+    /// This method returns a single perpetual stream that should only close
+    /// on fatal errors (if any). Yet, the POSIX' `accept` function may also
+    /// return transient errors (e.g. ECONNABORTED). The exact details differ
+    /// per operation system. For example, the Linux manual mentions:
+    ///
+    /// > Linux accept() passes already-pending network errors on the new
+    /// > socket as an error code from accept(). This behavior differs from
+    /// > other BSD socket implementations. For reliable operation the
+    /// > application should detect the network errors defined for the
+    /// > protocol after accept() and treat them like EAGAIN by retrying.
+    /// > In the case of TCP/IP, these are ENETDOWN, EPROTO, ENOPROTOOPT,
+    /// > EHOSTDOWN, ENONET, EHOSTUNREACH, EOPNOTSUPP, and ENETUNREACH.
+    /// Source: https://man7.org/linux/man-pages/man2/accept.2.html
+    ///
+    /// WASI implementations have two options to handle this:
+    /// - Optionally log it and then skip over non-fatal errors returned by
+    ///   `accept`. Guest code never gets to see these failures. Or:
+    /// - Synthesize a `tcp-socket` resource that exposes the error when
+    ///   attempting to send or receive on it. Guest code then sees these
+    ///   failures as regular I/O errors.
+    ///
+    /// In either case, the stream returned by this `listen` method remains
+    /// operational.
+    ///
+    /// WASI requires `listen` to perform an implicit bind if the socket
+    /// has not already been bound. Not all platforms (notably Windows)
+    /// exhibit this behavior out of the box. On platforms that require it,
+    /// the WASI implementation can emulate this behavior by performing
+    /// the bind itself if the guest hasn't already done so.
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/listen.html>
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/accept.html>
+    /// - <https://man7.org/linux/man-pages/man2/listen.2.html>
+    /// - <https://man7.org/linux/man-pages/man2/accept.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-listen>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-accept>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=listen&sektion=2>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=accept&sektion=2>
+    @since(version = 0.3.0)
+    listen: func() -> result<stream<tcp-socket>, error-code>;
+    /// Transmit data to peer.
+    ///
+    /// The caller should close the stream when it has no more data to send
+    /// to the peer. Under normal circumstances this will cause a FIN packet
+    /// to be sent out. Closing the stream is equivalent to calling
+    /// `shutdown(SHUT_WR)` in POSIX.
+    ///
+    /// This function may be called at most once and returns once the full
+    /// contents of the stream are transmitted or an error is encountered.
+    ///
+    /// # Typical errors
+    /// - `invalid-state`:             The socket is not in the `connected` state. (ENOTCONN)
+    /// - `invalid-state`:             `send` has already been called on this socket.
+    /// - `connection-broken`:         The connection is not writable anymore. (EPIPE, ECONNABORTED on Windows)
+    /// - `connection-reset`:          The connection was reset. (ECONNRESET)
+    /// - `remote-unreachable`:        The remote address is not reachable. (EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+    ///
+    ///  # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/send.html>
+    /// - <https://man7.org/linux/man-pages/man2/send.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-send>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=send&sektion=2>
+    @since(version = 0.3.0)
+    send: func(data: stream<u8>) -> future<result<_, error-code>>;
+    /// Read data from peer.
+    ///
+    /// Returns a `stream` of data sent by the peer. The implementation
+    /// drops the stream once no more data is available. At that point, the
+    /// returned `future` resolves to:
+    /// - `ok` after a graceful shutdown from the peer (i.e. a FIN packet), or
+    /// - `err` if the socket was closed abnormally.
+    ///
+    /// `receive` may be called only once per socket. Subsequent calls return
+    /// a closed stream and a future resolved to `err(invalid-state)`.
+    ///
+    /// If the caller is not expecting to receive any more data from the peer,
+    /// they should drop the stream. Any data still in the receive queue
+    /// will be discarded. This is equivalent to calling `shutdown(SHUT_RD)`
+    /// in POSIX.
+    ///
+    /// # Typical errors
+    /// - `invalid-state`:             The socket is not in the `connected` state. (ENOTCONN)
+    /// - `invalid-state`:             `receive` has already been called on this socket.
+    /// - `connection-reset`:          The connection was reset. (ECONNRESET)
+    /// - `remote-unreachable`:        The remote address is not reachable. (EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recv.html>
+    /// - <https://man7.org/linux/man-pages/man2/recv.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recv>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=recv&sektion=2>
+    @since(version = 0.3.0)
+    receive: func() -> tuple<stream<u8>, future<result<_, error-code>>>;
+    /// Get the bound local address.
+    ///
+    /// POSIX mentions:
+    /// > If the socket has not been bound to a local name, the value
+    /// > stored in the object pointed to by `address` is unspecified.
+    ///
+    /// WASI is stricter and requires `get-local-address` to return
+    /// `invalid-state` when the socket hasn't been bound yet.
+    ///
+    /// # Typical errors
+    /// - `invalid-state`: The socket is not bound to any local address.
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
+    /// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
+    /// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
+    @since(version = 0.3.0)
+    get-local-address: func() -> result<ip-socket-address, error-code>;
+    /// Get the remote address.
+    ///
+    /// # Typical errors
+    /// - `invalid-state`: The socket is not connected to a remote address. (ENOTCONN)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
+    /// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
+    @since(version = 0.3.0)
+    get-remote-address: func() -> result<ip-socket-address, error-code>;
+    /// Whether the socket is in the `listening` state.
+    ///
+    /// Equivalent to the SO_ACCEPTCONN socket option.
+    @since(version = 0.3.0)
+    get-is-listening: func() -> bool;
+    /// Whether this is a IPv4 or IPv6 socket.
+    ///
+    /// This is the value passed to the constructor.
+    ///
+    /// Equivalent to the SO_DOMAIN socket option.
+    @since(version = 0.3.0)
+    get-address-family: func() -> ip-address-family;
+    /// Hints the desired listen queue size. Implementations are free to
+    /// ignore this.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    /// Any other value will never cause an error, but it might be silently
+    /// clamped and/or rounded.
+    ///
+    /// # Typical errors
+    /// - `not-supported`:        (set) The platform does not support changing the backlog size after the initial listen.
+    /// - `invalid-argument`:     (set) The provided value was 0.
+    /// - `invalid-state`:        (set) The socket is in the `connecting` or `connected` state.
+    @since(version = 0.3.0)
+    set-listen-backlog-size: func(value: u64) -> result<_, error-code>;
+    /// Enables or disables keepalive.
+    ///
+    /// The keepalive behavior can be adjusted using:
+    /// - `keep-alive-idle-time`
+    /// - `keep-alive-interval`
+    /// - `keep-alive-count`
+    /// These properties can be configured while `keep-alive-enabled` is
+    /// false, but only come into effect when `keep-alive-enabled` is true.
+    ///
+    /// Equivalent to the SO_KEEPALIVE socket option.
+    @since(version = 0.3.0)
+    get-keep-alive-enabled: func() -> result<bool, error-code>;
+    @since(version = 0.3.0)
+    set-keep-alive-enabled: func(value: bool) -> result<_, error-code>;
+    /// Amount of time the connection has to be idle before TCP starts
+    /// sending keepalive packets.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    /// All other values are accepted without error, but may be
+    /// clamped or rounded. As a result, the value read back from
+    /// this setting may differ from the value that was set.
+    ///
+    /// Equivalent to the TCP_KEEPIDLE socket option. (TCP_KEEPALIVE on MacOS)
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:     (set) The provided value was 0.
+    @since(version = 0.3.0)
+    get-keep-alive-idle-time: func() -> result<duration, error-code>;
+    @since(version = 0.3.0)
+    set-keep-alive-idle-time: func(value: duration) -> result<_, error-code>;
+    /// The time between keepalive packets.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    /// All other values are accepted without error, but may be
+    /// clamped or rounded. As a result, the value read back from
+    /// this setting may differ from the value that was set.
+    ///
+    /// Equivalent to the TCP_KEEPINTVL socket option.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:     (set) The provided value was 0.
+    @since(version = 0.3.0)
+    get-keep-alive-interval: func() -> result<duration, error-code>;
+    @since(version = 0.3.0)
+    set-keep-alive-interval: func(value: duration) -> result<_, error-code>;
+    /// The maximum amount of keepalive packets TCP should send before
+    /// aborting the connection.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    /// All other values are accepted without error, but may be
+    /// clamped or rounded. As a result, the value read back from
+    /// this setting may differ from the value that was set.
+    ///
+    /// Equivalent to the TCP_KEEPCNT socket option.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:     (set) The provided value was 0.
+    @since(version = 0.3.0)
+    get-keep-alive-count: func() -> result<u32, error-code>;
+    @since(version = 0.3.0)
+    set-keep-alive-count: func(value: u32) -> result<_, error-code>;
+    /// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:     (set) The TTL value must be 1 or higher.
+    @since(version = 0.3.0)
+    get-hop-limit: func() -> result<u8, error-code>;
+    @since(version = 0.3.0)
+    set-hop-limit: func(value: u8) -> result<_, error-code>;
+    /// Kernel buffer space reserved for sending/receiving on this socket.
+    /// Implementations usually treat this as a cap the buffer can grow to,
+    /// rather than allocating the full amount immediately.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    /// All other values are accepted without error, but may be
+    /// clamped or rounded. As a result, the value read back from
+    /// this setting may differ from the value that was set.
+    ///
+    /// This is only a performance hint. The implementation may ignore it or
+    /// tweak it based on real traffic patterns.
+    /// Linux and macOS appear to behave differently depending on whether a
+    /// buffer size was explicitly set. When set, they tend to honor it; when
+    /// not set, they dynamically adjust the buffer size as the connection
+    /// progresses. This is especially noticeable when comparing the values
+    /// from before and after connection establishment.
+    ///
+    /// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:     (set) The provided value was 0.
+    @since(version = 0.3.0)
+    get-receive-buffer-size: func() -> result<u64, error-code>;
+    @since(version = 0.3.0)
+    set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
+    @since(version = 0.3.0)
+    get-send-buffer-size: func() -> result<u64, error-code>;
+    @since(version = 0.3.0)
+    set-send-buffer-size: func(value: u64) -> result<_, error-code>;
+  }
+
+  /// A UDP socket handle.
+  @since(version = 0.3.0)
+  resource udp-socket {
+    /// Create a new UDP socket.
+    ///
+    /// Similar to `socket(AF_INET or AF_INET6, SOCK_DGRAM, IPPROTO_UDP)`
+    /// in POSIX. On IPv6 sockets, IPV6_V6ONLY is enabled by default and
+    /// can't be configured otherwise.
+    ///
+    /// Unlike POSIX, WASI sockets have no notion of a socket-level
+    /// `O_NONBLOCK` flag. Instead they fully rely on the Component Model's
+    /// async support.
+    ///
+    /// # References:
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
+    /// - <https://man7.org/linux/man-pages/man2/socket.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
+    @since(version = 0.3.0)
+    create: static func(address-family: ip-address-family) -> result<udp-socket, error-code>;
+    /// Bind the socket to the provided IP address and port.
+    ///
+    /// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is
+    /// left to the implementation to decide which network interface(s) to
+    /// bind to. If the port is zero, the socket will be bound to a random
+    /// free port.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:          The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows)
+    /// - `invalid-state`:             The socket is already bound. (EINVAL)
+    /// - `address-in-use`:            No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
+    /// - `address-in-use`:            Address is already in use. (EADDRINUSE)
+    /// - `address-not-bindable`:      `local-address` is not an address that can be bound to. (EADDRNOTAVAIL)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
+    /// - <https://man7.org/linux/man-pages/man2/bind.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
+    @since(version = 0.3.0)
+    bind: func(local-address: ip-socket-address) -> result<_, error-code>;
+    /// Associate this socket with a specific peer address.
+    ///
+    /// On success, the `remote-address` of the socket is updated.
+    /// The `local-address` may be updated as well, based on the best network
+    /// path to `remote-address`. If the socket was not already explicitly
+    /// bound, this function will implicitly bind the socket to a random
+    /// free port.
+    ///
+    /// When a UDP socket is "connected", the `send` and `receive` methods
+    /// are limited to communicating with that peer only:
+    /// - `send` can only be used to send to this destination.
+    /// - `receive` will only return datagrams sent from the provided `remote-address`.
+    ///
+    /// The name "connect" was kept to align with the existing POSIX
+    /// terminology. Other than that, this function only changes the local
+    /// socket configuration and does not generate any network traffic.
+    /// The peer is not aware of this "connection".
+    ///
+    /// This method may be called multiple times on the same socket to change
+    /// its association, but only the most recent one will be effective.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:          The `remote-address` has the wrong address family. (EAFNOSUPPORT)
+    /// - `invalid-argument`:          The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
+    /// - `invalid-argument`:          The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
+    /// - `address-in-use`:            Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
+    ///
+    /// # Implementors note
+    /// If the socket is already connected, some platforms (e.g. Linux)
+    /// require a disconnect before connecting to a different peer address.
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
+    /// - <https://man7.org/linux/man-pages/man2/connect.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
+    /// - <https://man.freebsd.org/cgi/man.cgi?connect>
+    @since(version = 0.3.0)
+    connect: func(remote-address: ip-socket-address) -> result<_, error-code>;
+    /// Dissociate this socket from its peer address.
+    ///
+    /// After calling this method, `send` & `receive` are free to communicate
+    /// with any remote address again.
+    ///
+    /// The POSIX equivalent of this is calling `connect` with an `AF_UNSPEC` address.
+    ///
+    /// # Typical errors
+    /// - `invalid-state`:           The socket is not connected.
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
+    /// - <https://man7.org/linux/man-pages/man2/connect.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
+    /// - <https://man.freebsd.org/cgi/man.cgi?connect>
+    @since(version = 0.3.0)
+    disconnect: func() -> result<_, error-code>;
+    /// Send a message on the socket to a particular peer.
+    ///
+    /// If the socket is connected, the peer address may be left empty. In
+    /// that case this is equivalent to `send` in POSIX. Otherwise it is
+    /// equivalent to `sendto`.
+    ///
+    /// Additionally, if the socket is connected, a `remote-address` argument
+    /// _may_ be provided but then it must be identical to the address
+    /// passed to `connect`.
+    ///
+    /// If the socket has not been explicitly bound, it will be
+    /// implicitly bound to a random free port.
+    ///
+    /// Implementations may trap if the `data` length exceeds 64 KiB.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:        The `remote-address` has the wrong address family. (EAFNOSUPPORT)
+    /// - `invalid-argument`:        The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
+    /// - `invalid-argument`:        The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
+    /// - `invalid-argument`:        The socket is in "connected" mode and `remote-address` is `some` value that does not match the address passed to `connect`. (EISCONN)
+    /// - `invalid-argument`:        The socket is not "connected" and no value for `remote-address` was provided. (EDESTADDRREQ)
+    /// - `remote-unreachable`:      The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+    /// - `connection-refused`:      The connection was refused. (ECONNREFUSED)
+    /// - `datagram-too-large`:      The datagram is too large. (EMSGSIZE)
+    /// - `address-in-use`:          Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE)
+    ///
+    /// # Implementors note
+    /// WASI requires `send` to perform an implicit bind if the socket
+    /// has not been bound. Not all platforms (notably Windows) exhibit
+    /// this behavior natively. On such platforms, the WASI implementation
+    /// should emulate it by performing the bind if the guest has not
+    /// already done so.
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendto.html>
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendmsg.html>
+    /// - <https://man7.org/linux/man-pages/man2/send.2.html>
+    /// - <https://man7.org/linux/man-pages/man2/sendmmsg.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-send>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-sendto>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasendmsg>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=send&sektion=2>
+    @since(version = 0.3.0)
+    send: async func(data: list<u8>, remote-address: option<ip-socket-address>) -> result<_, error-code>;
+    /// Receive a message on the socket.
+    ///
+    /// On success, the return value contains a tuple of the received data
+    /// and the address of the sender. Theoretical maximum length of the
+    /// data is 64 KiB. Though in practice, it will typically be less than
+    /// 1500 bytes.
+    ///
+    /// If the socket is connected, the sender address is guaranteed to
+    /// match the remote address passed to `connect`.
+    ///
+    /// # Typical errors
+    /// - `invalid-state`:        The socket has not been bound yet.
+    /// - `remote-unreachable`:   The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+    /// - `connection-refused`:   The connection was refused. (ECONNREFUSED)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvfrom.html>
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvmsg.html>
+    /// - <https://man7.org/linux/man-pages/man2/recv.2.html>
+    /// - <https://man7.org/linux/man-pages/man2/recvmmsg.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recvfrom>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/mswsock/nc-mswsock-lpfn_wsarecvmsg>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=recv&sektion=2>
+    @since(version = 0.3.0)
+    receive: async func() -> result<tuple<list<u8>, ip-socket-address>, error-code>;
+    /// Get the current bound address.
+    ///
+    /// POSIX mentions:
+    /// > If the socket has not been bound to a local name, the value
+    /// > stored in the object pointed to by `address` is unspecified.
+    ///
+    /// WASI is stricter and requires `get-local-address` to return
+    /// `invalid-state` when the socket hasn't been bound yet.
+    ///
+    /// # Typical errors
+    /// - `invalid-state`: The socket is not bound to any local address.
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
+    /// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
+    /// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
+    @since(version = 0.3.0)
+    get-local-address: func() -> result<ip-socket-address, error-code>;
+    /// Get the address the socket is currently "connected" to.
+    ///
+    /// # Typical errors
+    /// - `invalid-state`: The socket is not "connected" to a specific remote address. (ENOTCONN)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
+    /// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
+    @since(version = 0.3.0)
+    get-remote-address: func() -> result<ip-socket-address, error-code>;
+    /// Whether this is a IPv4 or IPv6 socket.
+    ///
+    /// This is the value passed to the constructor.
+    ///
+    /// Equivalent to the SO_DOMAIN socket option.
+    @since(version = 0.3.0)
+    get-address-family: func() -> ip-address-family;
+    /// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:     (set) The TTL value must be 1 or higher.
+    @since(version = 0.3.0)
+    get-unicast-hop-limit: func() -> result<u8, error-code>;
+    @since(version = 0.3.0)
+    set-unicast-hop-limit: func(value: u8) -> result<_, error-code>;
+    /// Kernel buffer space reserved for sending/receiving on this socket.
+    /// Implementations usually treat this as a cap the buffer can grow to,
+    /// rather than allocating the full amount immediately.
+    ///
+    /// If the provided value is 0, an `invalid-argument` error is returned.
+    /// All other values are accepted without error, but may be
+    /// clamped or rounded. As a result, the value read back from
+    /// this setting may differ from the value that was set.
+    ///
+    /// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`:     (set) The provided value was 0.
+    @since(version = 0.3.0)
+    get-receive-buffer-size: func() -> result<u64, error-code>;
+    @since(version = 0.3.0)
+    set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
+    @since(version = 0.3.0)
+    get-send-buffer-size: func() -> result<u64, error-code>;
+    @since(version = 0.3.0)
+    set-send-buffer-size: func(value: u64) -> result<_, error-code>;
+  }
+}
+
+@since(version = 0.3.0)
+interface ip-name-lookup {
+  @since(version = 0.3.0)
+  use types.{ip-address};
+
+  /// Lookup error codes.
+  @since(version = 0.3.0)
+  variant error-code {
+    /// Access denied.
+    ///
+    /// POSIX equivalent: EACCES, EPERM
+    access-denied,
+    /// `name` is a syntactically invalid domain name or IP address.
+    ///
+    /// POSIX equivalent: EINVAL
+    invalid-argument,
+    /// Name does not exist or has no suitable associated IP addresses.
+    ///
+    /// POSIX equivalent: EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY
+    name-unresolvable,
+    /// A temporary failure in name resolution occurred.
+    ///
+    /// POSIX equivalent: EAI_AGAIN
+    temporary-resolver-failure,
+    /// A permanent failure in name resolution occurred.
+    ///
+    /// POSIX equivalent: EAI_FAIL
+    permanent-resolver-failure,
+    /// A catch-all for errors not captured by the existing variants.
+    /// Implementations can use this to extend the error type without
+    /// breaking existing code.
+    other(option<string>),
+  }
+
+  /// Resolve an internet host name to a list of IP addresses.
+  ///
+  /// Unicode domain names are automatically converted to ASCII using IDNA
+  /// encoding. If the input is an IP address string, the address is parsed
+  /// and returned as-is without making any external requests.
+  ///
+  /// See the wasi-socket proposal README.md for a comparison with getaddrinfo.
+  ///
+  /// The results are returned in connection order preference.
+  ///
+  /// This function never succeeds with 0 results. It either fails or succeeds
+  /// with at least one address. Additionally, this function never returns
+  /// IPv4-mapped IPv6 addresses.
+  ///
+  /// # References:
+  /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
+  /// - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html>
+  /// - <https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo>
+  /// - <https://man.freebsd.org/cgi/man.cgi?query=getaddrinfo&sektion=3>
+  @since(version = 0.3.0)
+  resolve-addresses: async func(name: string) -> result<list<ip-address>, error-code>;
+}
+
+@since(version = 0.3.0)
+world imports {
+  @since(version = 0.3.0)
+  import wasi:clocks/types@0.3.0;
+  @since(version = 0.3.0)
+  import types;
+  @since(version = 0.3.0)
+  import ip-name-lookup;
+}
diff --git a/sdks/go/golem/wit/main.wit b/sdks/go/golem/wit/main.wit
new file mode 100644
index 0000000000..99da878700
--- /dev/null
+++ b/sdks/go/golem/wit/main.wit
@@ -0,0 +1,49 @@
+package golem:agent-guest;
+
+world agent-guest {
+  import golem:api/host@1.5.0;
+  import golem:agent/host@2.0.0;
+
+  import golem:rdbms/ignite2@1.5.0;
+  import golem:rdbms/postgres@1.5.0;
+  import golem:rdbms/mysql@1.5.0;
+  import golem:rdbms/types@1.5.0;
+
+  import golem:api/context@1.5.0;
+  import golem:api/oplog@1.5.0;
+  import golem:api/retry@1.5.0;
+  import golem:durability/durability@1.5.0;
+  import golem:quota/types@1.5.0;
+  import golem:secrets/types@0.1.0;
+  import golem:secrets/reveal@0.1.0;
+
+  import wasi:cli/environment@0.3.0;
+
+  import wasi:blobstore/blobstore;
+  import wasi:blobstore/container;
+  import wasi:blobstore/types;
+
+  import wasi:keyvalue/eventual@0.1.0;
+  import wasi:keyvalue/eventual-batch@0.1.0;
+  import wasi:keyvalue/types@0.1.0;
+  import wasi:keyvalue/wasi-keyvalue-error@0.1.0;
+
+  import wasi:config/store@0.2.0-draft;
+
+  import wasi:logging/logging;
+
+  import golem:websocket/client@1.5.0;
+
+  // Outgoing HTTP. HTTP is not part of the agent world: each SDK imports it
+  // itself. p3 collapses p2's outgoing-handler/future dance into a single
+  // `send: async func`, which surfaces in Go as a plain blocking call.
+  import wasi:http/client@0.3.0;
+
+  include golem:agent/agent-guest@2.0.0;
+
+  // TODO(phase 6): export golem:tool/guest@0.1.0 once the tool registry lands.
+  // (The TS runtime omits it due to p3 nested streams; Go has no such limit.)
+
+  export golem:api/save-snapshot@1.5.0;
+  export golem:api/load-snapshot@1.5.0;
+}